C++ 基础概念速览与常见用法

嵌套命名空间

同一个大命名空间里还可以继续分层。实际写代码时，这比硬把所有名字堆在一起更清楚。

#include<stdio.h>
namespace code {
    namespace codeA {
        int a = 10;
    }
    namespace codeB {
        int a = 20;
    }
}

int main() {
    printf("%d\n", code::codeA::a); // 打印 10
    printf("%d\n", code::codeB::a); // 打印 20
}

常见用法

除了直接写全名，还有两种方式：

• 只引入某个成员

using name::a; // 只引入 a

• 引入整个命名空间

using namespace name; // 引入所有成员

后者图省事，但污染也明显，尤其在头文件和公共代码里，我一般都会躲开。

C++ 允许同一个命名空间分散在多个文件里，编译器会把它们合并起来。标准库统一放在 std 命名空间中。

C++ 的输入输出

C++ 的标准输入输出头文件是 <iostream>，它提供了 cin、cout 以及流操作符 <<、>>。

cin 和 cout

std::cin 用来从控制台读数据，std::cout 用来往控制台写数据。它们都在 std 命名空间里，所以通常会写 using namespace std;，或者直接加 std:: 前缀。

流操作符

• << 配合 cout，负责输出
• >> 配合 cin，负责输入

#include<iostream>
using namespace std;

int main() {
    cout << "hello world" << endl;
    cout << "我的刀盾喜欢奶龙" << endl << "咕咕嘎嘎" << endl;
    
    int a, b;
    cout << "请输入两个整数:";
    cin >> a >> b;
    cout << "两个数之和为:" << a + b << endl;
}

这里最方便的地方，是不用像 C 那样手动写格式占位符，编译器会按变量类型处理。endl 会换行，并顺手刷新缓冲区。

缺省参数

缺省参数就是给函数参数一个默认值。调用时不传，就用默认值；传了，就覆盖掉。

全缺省和半缺省

• 全缺省：所有参数都有默认值
• 半缺省：只有部分参数有默认值

C++ 对缺省参数的顺序要求很死：必须从右往左连续设置。也就是说，左边不能空着，右边却有默认值。

#include<iostream>
using namespace std;

// 正确：缺省值从右向左
void Print(int a, int b = 1, int c = 2) {
    cout << a << "," << b << "," << c << endl;
}

int main() {
    Print(0);      // 打印 0,1,2
    Print(6, 6);   // 打印 6,6,2
    Print(5, 5, 5);// 打印 5,5,5
    // Print();    // 错误：没传够非缺省参数
}

函数声明和定义分开写时，缺省参数放在声明里更稳妥，别两边都写。

函数重载

同一个作用域里，C++ 允许出现多个同名函数，只要参数列表不同。区别可以是参数个数不同，也可以是类型或者顺序不同。

#include<iostream>
using namespace std;

// 参数个数不同
int Add(int a, int b, int c) { return a + b + c; }
int Add(int a, int b) { return a + b; }

// 参数类型不同
double Calc(int a, double b) { return a + b; }
double Calc(double a, int b) { return a - b; }

int main() {
    cout << Add(1, 1, 1) << endl; // 调用三参数版本
    cout << Add(1, 1) << endl;    // 调用两参数版本
    
    cout << Calc(2, 2.2) << endl; // 第一个是 int，第二个是 double
    cout << Calc(2.2, 2) << endl; // 第一个是 double，第二个是 int
}

这种写法比起给函数起一堆相近名字，要顺手得多。

引用

引用可以看成已有变量的别名。它不复制数据，直接绑定到原变量上，改引用就是改原变量。

引用和指针

以前交换变量常写指针版本，现在引用版本更干净：

// 指针写法
void Swap(int* a, int* b) {
    int tmp = *a;
    *a = *b;
    *b = tmp;
}

// 引用写法
void Swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

引用不用写 * 解引用，读起来更像在操作普通变量。

引用的几个限制

• 定义时必须初始化，绑定之后不能再改绑到别的对象
• 一个变量可以有多个引用，改其中一个，原变量和其他引用都会跟着变
• 没有空引用这一说，写起来比指针少很多边界判断

const 引用

const 引用常用来传参。它的价值很实际：既避免拷贝，又不让函数内部乱改数据。

权限控制

• 原变量可读可写，const 引用把它限制成只读
• 原变量本身就是 const 时，const 引用也只能读

int main() {
    int a = 3;
    const int& ra = a; // 安全，ra 只能读
    // ra = 3;        // 错误：超出权限
}

绑定临时变量

普通引用不能绑临时变量，比如字面量，因为它既短命又不可写。const 引用可以接住它，还会顺手延长生命周期。

int main() {
    const double& ra = 20; // 安全
    // int& rra = 20;      // 错误：权限放大
}

宏与内联函数

宏

宏发生在预处理阶段，本质上就是文本替换。它有无参和有参两种写法，快是快，但不受类型检查约束，优先级也容易出坑。

#define Add(a,b) ((a) + (b))

内联函数

内联函数会建议编译器把函数体展开到调用处，省掉一些函数调用开销。它保留了函数的类型检查，也比宏更好调。

nullptr

C++11 引入了 nullptr，专门表示空指针，用来替代老的 NULL。

为什么要换成 nullptr

NULL 在 C++ 里通常就是 0。这在重载场景里很烦，因为它可能被当成整数，而不是空指针。

#include<iostream>
using namespace std;

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

int main() {
    Print(NULL);     // 实际调用 Print(int)，因为 NULL 是 0
    Print(nullptr);  // 正确调用 Print(int*)
}

nullptr 的意思更明确，重载时也少歧义。这个改动不花哨，但很实用。