C++ 基础知识入门：命名空间、引用与函数重载 | 极客日志

C++算法

C++ 基础知识入门：命名空间、引用与函数重载

系统讲解 C++基础知识，包括首个程序的编写、命名空间的定义与作用、标准输入输出流的使用、缺省参数规则、函数重载机制、引用的概念与特性、内联函数的优化原理以及 nullptr 关键字的正确用法。通过代码示例和对比分析，帮助读者理解核心语法并避免常见错误。

虚拟内存发布于 2026/3/30更新于 2026/4/131 浏览

C++ 基础知识入门：命名空间、引用与函数重载

C++ 入门基础

1. C++的第一个程序

#include <iostream>
using namespace std;

int main() {
    cout << "Hello World" << endl;
    return 0;
}

2. 命名空间

2.1 namespace 的价值

在 C/C++ 中，变量、函数和类大量存在，名称都存在于全局作用域中，可能会导致冲突。命名空间的目的是对标识符进行本地化，以避免命名冲突，namespace关键字的出现就是针对这种问题的。

2.2 namespace 的定义

定义命名空间需要使用 namespace关键字，后面跟命名空间的名字，然后接一对 {}即可，{}中即为命名空间的成员，可以定义变量、函数、类型等。
namespace本质是定义一个域，这个域跟全局域各自独立，不同的域可以定义同名变量。
C++中域有函数局部域、全局域、命名空间域、类域；域影响的是编译时语法查找一个变量/函数/类型出处的逻辑。
namespace只能定义在全局，当然它还可以嵌套定义。
项目工程中多文件中定义的同名 namespace会认为是同一个 namespace，不会冲突。
C++标准库都放在一个叫 std(standard)的命名空间中。

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
using namespace std;

namespace abc {
    int rand = 10;
    int Add(int left, int right) {
        return left + right;
    }
    struct Node {
         * next;
         val;
    };
}

{
    
    (, rand);
    
    (, abc::rand);
     ;
}

极客日志微信公众号二维码

更多推荐文章

相关免费在线工具

加密/解密文本
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。在线工具，加密/解密文本在线工具，online
Base64 字符串编码/解码
将字符串编码和解码为其 Base64 格式表示形式即可。在线工具，Base64 字符串编码/解码在线工具，online
Base64 文件转换器
将字符串、文件或图像转换为其 Base64 表示形式。在线工具，Base64 文件转换器在线工具，online
Markdown 转 HTML
将 Markdown（GFM）转为 HTML 片段，浏览器内 marked 解析；与 HTML 转 Markdown 互为补充。在线工具，Markdown 转 HTML在线工具，online
HTML 转 Markdown
将 HTML 片段转为 GitHub Flavored Markdown，支持标题、列表、链接、代码块与表格等；浏览器内处理，可链接预填。在线工具，HTML 转 Markdown在线工具，online
JSON 压缩
通过删除不必要的空白来缩小和压缩JSON。在线工具，JSON 压缩在线工具，online

// 关于命名空间的嵌套
namespace asd {
    namespace aaa {
        int rand = 15;
    }
    namespace bbb {
        int rand = 20;
    }
}

int main() {
    printf("%d\n", asd::aaa::rand);
    printf("%d\n", asd::bbb::rand);
    return 0;
}

namespace N {
    int a = 0;
    int b = 0;
}

// 指定命名空间访问
int main() {
    printf("%d\n", N::a);
    return 0;
}

// 将命名空间中某个成员展开
using N::b;
int main() {
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;
}

// 将命名空间全部展开
using namespace N;
int main() {
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}

#include <stdio.h>
using namespace std;

int main() {
    int a = 0;
    double b = 0.1;
    char c = 'x';
    cout << a << " " << b << " " << c << endl;
    std::cout << a << b << c << std::endl;
    scanf("%d%lf\n", &a, &b);
    printf("%d %lf\n", a, b);
    return 0;
}

ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);

#include <iostream>
#include <assert.h>
using namespace std;

void Func(int a = 0) {
    cout << a << endl;
}

int main() {
    Func();
    Func(10);
    // 没有传参时，使用参数的默认值
    // 传参时，使用指定的实参
    return 0;
}

#include <iostream>
using namespace std;

// 全缺省
void Func1(int a = 10, int b = 20, int c = 30) {
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

// 半缺省
void Func2(int a, int b = 10, int c = 20) {
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl << endl;
}

int main() {
    Func1();
    Func1(1);
    Func1(1, 2);
    Func1(1, 2, 3);
    Func2(100);
    Func2(100, 200);
    Func2(100, 200, 300);
    return 0;
}

#include <iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right) {
    cout << "int Add(int left, int right)" << endl;
    return left + right;
}

double Add(double left, double right) {
    cout << "double Add(double left, double right)" << endl;
    return left + right;
}

// 2、参数个数不同
void f() {
    cout << "f()" << endl;
}
void f(int a) {
    cout << "f(int a)" << endl;
}

// 3、参数类型顺序不同
void f(int a, char b) {
    cout << "f(int a, char b)" << endl;
}
void f(char b, int a) {
    cout << "f(char b, int a)" << endl;
}

// 返回值不同不能作为重载条件

int main() {
    Add(10, 20);
    Add(10.1, 20.2);
    f();
    f(10);
    f(10, 'a');
    f('a', 10);
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int a = 0;
    // 引用：b 和 c 是 a 的别名
    int& b = a;
    int& c = a;
    // 也可以给别名 b 取别名，d 相当于还是 a 的别名
    int& d = b;
    ++d;
    // 这里取地址我们看到是一样的
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    cout << &d << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    // 编译报错：'ra': 必须初始化
    // int& ra;
    int& b = a;
    int c = 20;
    // 这里并非让 b 引用 c，这里是一个赋值 b = c;
    cout << &a << endl;
    cout << &b << endl;
    cout << &c << endl;
    return 0;
}

void Swap(int& rx, int& ry) {
    int tmp = rx; rx = ry; ry = tmp;
}

int main() {
    int x = 0, y = 1;
    cout << x << " " << y << endl;
    Swap(x, y);
    cout << x << " " << y << endl;
    return 0;
}

#include <iostream>
using namespace std;

int main() {
    const int a = 10;
    // 这里引用对 a 访问权限放大
    // int& ra = a;
    // 这样可以
    const int& ra = a;
    // 不能给常量赋值
    // ra++;
    
    // 这里引用对 b 访问权限缩小
    int b = 20;
    const int& rb = b;
    // 不能给常量赋值
    // rb++;
    return 0;
}

int main() {
    int a = 10;
    const int& ra = 30;
    // 编译报错：'初始化':无法从'int'转换为'int &'
    // int& rb = a * 3;
    const int& rb = a * 3;
    double d = 12.34;
    // 编译报错：'初始化':无法从'double'转换为'int &'
    // int& rd = d;
    const int& rd = d;
    return 0;
}

#include <iostream>
using namespace std;

inline int Add(int x, int y) {
    int ret = x + y; ret += 1; ret += 1; ret += 1;
    return ret;
}

int main() {
    // 可以通过汇编观察程序是否展开
    // 有 call Add 语句就是没有展开，没有就是展开了
    int ret = Add(1, 2);
    cout << Add(1, 2) * 5 << endl;
    return 0;
}

#include <iostream>
using namespace std;

// 实现一个 ADD 宏函数的常见问题
// #define ADD(int a, int b) return a + b;
// #define ADD(a, b) a + b;
// #define ADD(a, b) (a + b);
// 正确的宏实现
// #define ADD(a, b) ((a) + (b))
// 为什么不能加分号？
// 为什么要加外面的括号？
// 为什么要加里面的括号？

int main() {
    int ret = ADD(1, 2);
    cout << ADD(1, 2) << endl;
    cout << ADD(1, 2) * 5 << endl;
    int x = 1, y = 2;
    ADD(x & y, x | y); // -> (x&y+x|y)
    return 0;
}

// F.h
#include <iostream>
using namespace std;
inline void f(int i);

// F.cpp
#include "F.h"
void f(int i) {
    cout << i << endl;
}

// main.cpp
#include "F.h"
int main() {
    // 链接错误：无法解析的外部符号 f(10);
    f(10);
    f(10);
    return 0;
}

#include <iostream>
using namespace std;

void f(int x) {
    cout << "f(int x)" << endl;
}

void f(int* ptr) {
    cout << "f(int* ptr)" << endl;
}

int main() {
    f(0);
    // 本想通过 f(NULL)调用指针版本的 f(int* ptr)函数
    // 但是由于 NULL 被定义成 0，调用了 f(int x)
    // 因此与程序的初衷相悖。
    f(NULL);
    f((int*)NULL);
    // 编译报错：error C2665: 'f': 2 个重载中没有一个可以转换所有参数类型
    // f((void*)NULL);
    f(nullptr);
    
    // C++，必须强转
    void* p1 = nullptr;
    int* p2 = p1;
    
    // C语言有隐式类型转换，可以通过
    // void* p1 = NULL;
    // int* p2 = p1;
    return 0;
}