C++ 初阶：命名空间、输入输出、缺省参数与函数重载

namespace m {
    namespace n {
        int a = 0;
        int b = 9;
    }
    int c = 6;
}

• 多文件：工程中多个文件中定义的同名 namespace 会被视为同一个 namespace，不会冲突。
• 标准库：C++ 标准库通常放在 std (standard) 命名空间中。

1.3 namespace 使用

默认查找只在局部或全局进行，访问命名空间成员有三种方式：

1. 指定命名空间访问（推荐）：

std::cout

2. using 展开特定成员（无冲突时推荐）：

using m::a;

3. 展开全部成员（小练习可用，项目慎用）：

using namespace std;

二、输入输出

#include <iostream>

int main() {
    int a = 0;
    double b = 0;
    std::cin >> a >> b;
    std::cout << a << " " << b << std::endl;
    return 0;
}

• IO Stream：Input Output Stream 缩写，是标准的输入输出流库。
• 对象：std::cin 是 istream 类对象，面向窄字符输入；std::cout 是 ostream 类对象，面向窄字符输出。
• 操作符：<< 是流插入运算符，>> 是流提取运算符。
• 优势：自动识别变量类型，无需像 printf/scanf 那样手动指定格式。
• 性能优化：在 IO 需求高的场景（如竞赛），建议关闭同步以提升速度：

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

三、缺省参数

缺省参数指声明或定义时为形参指定默认值。调用时若未传实参则用默认值，否则用实参。分为全缺省和半缺省。

#include <iostream>
using namespace std;

int Add(int a = 1, int b = 2) {
    return a + b;
}

int main() {
    cout << Add(4, 3) << endl; // 输出 7
    cout << Add() << endl;     // 输出 3
    return 0;
}

• 规则：半缺省必须从右往左连续缺省，不能跳跃。调用时必须从左往右依次传参。
• 分离声明定义：缺省参数只能出现在函数声明或定义中的一处，通常建议在声明处给出。

四、函数重载

C++ 支持同一作用域内同名函数，前提是形参不同（个数或类型不同）。C 语言不支持此特性。

4.1 参数类型不同

void Add(int a, int b) { cout << a + b << endl; }
void Add(double a, double b) { cout << a + b << endl; }
// 调用时根据传入类型自动匹配

4.2 参数个数不同

void fuc() { cout << "haha" << endl; }
void fuc(int a) { cout << "hehe" << endl; }

4.3 参数类型顺序不同

void fuc(int a, char b) { cout << "haha" << endl; }
void fuc(char b, int a) { cout << "hehe" << endl; }

4.4 错误点

• 返回值不同：不能作为重载条件，调用时无法区分。
• 缺省参数歧义：若存在缺省参数导致调用不明确，编译器会报错。

void f1() { cout << "f()" << endl; }
void f1(int a = 10) { cout << "f(int a)" << endl; }
// f1(); 此时编译器不知道调用哪个

解决方法：利用命名空间隔离。

namespace m {
    void f1(int a = 10) { cout << "f(int a)" << endl; }
}
// 调用时明确指定 f1() 或 m::f1()

五、引用

5.1 引用概念

引用是变量的别名，不占用额外内存空间。

int a = 0;
int& b = a; // b 是 a 的别名
int& c = b; // c 也是 a 的别名

5.2 引用特性

• 必须初始化：定义时必须绑定对象。
• 不可更改指向：一旦引用某实体，不能再引用其他对象（赋值操作仅修改值，不改变绑定关系）。

5.3 引用使用

主要用于引用传参和返回，减少拷贝提高效率，或直接修改原对象。

#include <iostream>
#include <cstdlib>
using namespace std;

typedef int STDataType;
typedef struct Stack {
    STDataType* a;
    int top;
    int capacity;
} ST;

void STInit(ST& rs, int n = 4) {
    rs.a = (STDataType*)malloc(n * sizeof(STDataType));
    rs.top = 0;
    rs.capacity = n;
}

void STPush(ST& rs, STDataType x) {
    if (rs.capacity == rs.top) {
        int newcapacity = (rs.capacity == 0 ? 4 : rs.capacity * 2);
        STDataType* ptr = (STDataType*)realloc(rs.a, sizeof(STDataType) * newcapacity);
        if (ptr == NULL) {
            perror("realloc");
            return;
        }
        rs.a = ptr;
        rs.capacity = newcapacity;
    }
    rs.a[rs.top++] = x;
}

int& STTop(ST& rs) {
    return rs.a[rs.top - 1];
}

void STDestroy(ST& rs) {
    if (rs.a == NULL) return;
    free(rs.a);
    rs.a = nullptr;
    rs.capacity = rs.top = 0;
}

int main() {
    ST rs;
    STInit(rs);
    STPush(rs, 1);
    STPush(rs, 2);
    cout << STTop(rs) << endl;
    STTop(rs) = 10; // 通过引用直接修改栈顶元素
    cout << STTop(rs) << endl;
    STDestroy(rs);
    return 0;
}

5.4 const 引用

• 可以引用 const 对象，且必须用 const 引用。
• 临时对象具有常性，若需绑定普通对象到 const 引用，可防止误修改。

double a = 1.23;
const int& b = a; // 隐式转换产生临时对象，必须用 const 引用

六、指针和引用

七、inline

内联函数在编译时将函数体展开到调用处，省去栈帧建立开销，适合频繁调用的短小函数。递归函数或复杂函数通常会被编译器忽略。

inline void Swap(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

• 替代宏：相比 C 语言宏，inline 有类型检查，更安全且方便调试。
• 声明定义分离：不建议将 inline 函数的声明和定义分离到不同文件，否则可能导致链接错误。

八、nullptr

8.1 问题引入

使用 NULL 调用重载函数时，可能因 NULL 被定义为 0 而意外调用整型版本，而非指针版本。

8.2 原因分析

C++ 中 NULL 可能是字面常量 0，也可能是 (void*)0。这导致类型推断的不确定性。

8.3 解决方法

C++11 引入 nullptr 关键字。它是一个特殊类型的字面量，只能隐式转换为指针类型，不能转换为整数类型，从而彻底解决歧义。

void fuc(int* a) { cout << "pointer" << endl; }
void fuc(int a) { cout << "int" << endl; }

int main() {
    fuc(nullptr); // 明确调用指针版本
    return 0;
}