命名空间#

什么是命名空间#

1
#include <iostream>
2
// using namespace std;  // 这行是什么意思？
3

4
int main()
5
{
6
    std::cout << "hello world" << std::endl;
7
    return 0;
8
}

**知识点解释

std是C++标准库的命名空间，就像一个大文件夹
cout、endl等都放在这个”文件夹”里
using namespace std相当于说”我要用std文件夹里的所有东西”
不加这行的话，每次都要写std::cout，就像写”文件夹/文件”

为什么需要命名空间#

1
#include <stdlib.h>
2

3
int rand = 10;  // 问题：stdlib.h里也有个rand函数
4

5
int main()
6
{
7
    printf("%d\n", rand);  // 编译错误！名字冲突了
8
    return 0;
9
}

**使用命名空间解决命名冲突

1
#include <stdlib.h>
2

3
namespace my_space  // 创建自己的命名空间
4
{
5
    int rand = 10;  // 这个rand在my_space里，不会冲突
6
}
7

8
int main()
9
{
10
    printf("%p\n", rand);           // 访问全局的rand函数
11
    printf("%d\n", my_space::rand); // 访问我自己的rand变量
12
    return 0;
13
}

三种使用方式#

1
namespace bit {
2
    int a = 0;
3
    int b = 1;
4
}
5

6
// 方式1：指定命名空间（最安全）
7
std::cout << bit::a << std::endl;
8

9
// 方式2：展开特定成员
10
using bit::b;
11
cout << b << endl;
12

13
// 方式3：展开整个命名空间（最方便但可能冲突）
14
using namespace bit;
15
cout << a << " " << b << endl;

cin与cout#

基本用法#

1
#include <iostream>
2
using namespace std;
3

4
int main()
5
{
6
    int a;
7
    double b;
8
    char c;
9

10
    // 输入 - 自动识别类型！
11
    cin >> a >> b >> c;
12

13
    // 输出 - 不用记%d %f %c了！
14
    cout << "a=" << a << ", b=" << b << ", c=" << c << endl;
15

16
    return 0;
17
}

优势#

自动识别变量类型
不用写格式控制符
更安全，不容易出错
支持自定义类型的输入输出

缺省参数#

什么是缺省参数#

1
// 给函数参数设置默认值
2
void introduce(string name = "未知", int age = 0)
3
{
4
    cout << "我叫" << name << "，今年" << age << "岁" << endl;
5
}
6

7
int main()
8
{
9
    introduce("张三", 20);  // 我叫张三，今年20岁
10
    introduce("李四");      // 我叫李四，今年0岁
11
    introduce();            // 我叫未知，今年0岁
12

13
    return 0;
14
}

规则说明#

1
// 全缺省 - 所有参数都有默认值
2
void func1(int a = 10, int b = 20, int c = 30);
3

4
// 半缺省 - 部分参数有默认值（必须从右往左）
5
void func2(int a, int b = 20, int c = 30);  // ✅ 正确
6
// void func3(int a = 10, int b, int c = 30); // ❌ 错误！
7

8
int main()
9
{
10
    func2(100);        // a=100, b=20, c=30
11
    func2(100, 200);   // a=100, b=200, c=30
12
    func2(100, 200, 300);
13

14
    return 0;
15
}

函数重载-同名不同参#

什么是函数重载#

1
// 同一个函数名，不同的参数列表
2
int add(int a, int b) {
3
    cout << "整数加法" << endl;
4
    return a + b;
5
}
6

7
double add(double a, double b) {
8
    cout << "小数加法" << endl;
9
    return a + b;
10
}
11

12
void add(string a, string b) {
13
    cout << "字符串连接: " << a + b << endl;
14
}
15

16
int main()
17
{
18
    add(1, 2);           // 调用整数版本
19
    add(1.1, 2.2);       // 调用小数版本
20
    add("Hello", "World"); // 调用字符串版本
21

22
    return 0;
23
}

重载条件：#

参数类型不同
参数个数不同
参数顺序不同
仅返回类型不同**不可重载

引用-变量别名#

引用是什么#

1
int main()
2
{
3
    int original = 100;
4

5
    // 创建引用（别名）
6
    int& alias = original;  // alias是original的别名
7

8
    cout << "original = " << original << endl;  // 100
9
    cout << "alias = " << alias << endl;        // 100
10

11
    alias = 200;  // 通过别名修改值
12

13
    cout << "修改后 original = " << original << endl;  // 200
14
    cout << "两个变量的地址相同吗？" << endl;
15
    cout << &original << " == " << &alias << endl;  // 地址相同！
16

17
    return 0;
18
}

引用的重要特性#

1
int main()
2
{
3
    int a = 10;
4

5
    // 特性1：必须初始化
6
    int& ref = a;        // ✅ 正确
7
    // int& ref2;         // ❌ 错误！引用必须初始化
8

9
    // 特性2：不能改变指向
10
    int b = 20;
11
    ref = b;            // 这是赋值，不是改变指向！
12

13
    cout << a << endl;   // 20，a的值被改变了
14
    cout << &a << " " << &ref << endl;  // 地址还是a的地址
15

16
    return 0;
17
}

引用的实用场景#

1
// 场景1：引用传参（避免拷贝，直接修改）
2
void swap(int& x, int& y) {
3
    int temp = x;
4
    x = y;
5
    y = temp;
6
}
7

8
// 场景2：引用返回（可以当左值）
9
int& getElement(int arr[], int index) {
10
    return arr[index];
11
}
12

13
int main()
14
{
15
    int x = 1, y = 2;
16
    swap(x, y);  // 直接传变量，不用取地址
17

18
    int arr[5] = {1, 2, 3, 4, 5};
19
    getElement(arr, 2) = 100;  // 直接修改数组元素
20
    cout << arr[2] << endl;    // 100
21

22
    return 0;
23
}

const引用#

基本概念#

1
void const_reference_basics()
2
{
3
    int original = 100;
4

5
    // 普通引用
6
    int& ref1 = original;   // 可以读写
7
    ref1 = 200;             // ✅ 可以修改
8

9
    // const引用
10
    const int& ref2 = original;  // 只读引用
11
    // ref2 = 300;               // ❌ 错误！不能通过const引用修改
12

13
    cout << "original = " << original << endl;
14
    cout << "ref2 = " << ref2 << endl;
15
}

const引用的重要特性#

1
void const_reference_features()
2
{
3
    // 1. 权限缩小原则
4
    int a = 10;
5
    const int& cra = a;     // ✅ 权限缩小：可读写 → 只读
6

7
    // const int b = 20;
8
    // int& rb = b;         // ❌ 错误！权限放大：只读 → 可读写
9

10
    // 2. 绑定临时对象
11
    const int& temp_ref1 = 100;          // ✅ 正确
12
    const int& temp_ref2 = a + 50;       // ✅ 正确
13
    const double& temp_ref3 = 3.14;      // ✅ 正确
14

15
    // int& bad_ref1 = 100;              // ❌ 错误！
16
    // int& bad_ref2 = a + 50;           // ❌ 错误！
17

18
    // 3. 类型转换时的临时对象
19
    double d = 12.34;
20
    const int& int_ref = d;  // ✅ 创建临时int对象，绑定到const引用
21
    // int& bad_int_ref = d; // ❌ 错误！
22

23
    cout << "d = " << d << endl;
24
    cout << "int_ref = " << int_ref << endl;  // 12
25
}

const引用的实用场景#

1
// 场景1：函数参数 - 避免拷贝，同时保护数据
2
void print_large_object(const vector<int>& data) {
3
    // data不会被意外修改，同时避免拷贝整个vector
4
    for(const int& num : data) {
5
        cout << num << " ";
6
    }
7
    cout << endl;
8
    // data.push_back(100);  // ❌ 编译错误！
9
}
10

11
// 场景2：返回const引用保护成员变量
12
class Student {
13
private:
14
    string name;
15
public:
16
    const string& get_name() const {  // 返回const引用
17
        return name;  // 避免拷贝，同时保护name不被外部修改
18
    }
19
};
20

21
// 场景3：高效遍历
22
void efficient_traversal(const vector<string>& words) {
23
    for(const string& word : words) {  // 避免字符串拷贝
24
        cout << word << " ";
25
    }
26
}
27

28
void demonstrate_const_ref_usage()
29
{
30
    vector<int> big_data = {1, 2, 3, 4, 5};
31
    print_large_object(big_data);  // 高效且安全
32

33
    vector<string> texts = {"hello", "world", "cpp"};
34
    efficient_traversal(texts);    // 避免字符串拷贝
35
}

综合总结表#

特性	指针	引用	const引用
本质	存储地址的变量	变量的别名	只读别名
初始化	可不初始化	必须初始化	必须初始化
指向可变	✅ 可以改变	❌ 不能改变	❌ 不能改变
空值	✅ 可以为nullptr	❌ 不能为空	❌ 不能为空
访问方式	需要解引用(*)	直接使用	直接使用(只读)
重指向	✅ 可以	❌ 不能	❌ 不能
多级	✅ 支持多级指针	❌ 不支持	❌ 不支持
安全性	较低(野指针)	较高	最高

指针与引用的区别#

1
#include <iostream>
2
using namespace std;
3

4
void compare_pointers_references()
5
{
6
    int a = 10;
7
    int b = 20;
8

9
    // 1. 语法概念
10
    //引⽤是⼀个变量的取别名不开空间，指针是存储⼀个变量地址，要开空间
11
    int* p = &a;        // 指针需要取地址，存储地址
12
    int& r = a;         // 引用直接初始化，是别名
13

14
    // 2. 初始化要求
15
    // int* p2;         // ❌ 指针可以不初始化（危险！）
16
    // int& r2;         // ✅ 引用必须初始化
17

18
    // 3. 指向可变性
19
    p = &b;             // ✅ 指针可以改变指向
20
    // r = b;           // ❌ 这不是改变指向，这是赋值！
21
    // 引用一旦绑定，终身不变
22

23
    // 4. 访问方式
24
    *p = 30;            // 指针需要解引用
25
    r = 40;             // 引用直接使用
26

27
    // 5. 空值情况
28
    p = nullptr;        // ✅ 指针可以为空
29
    // int& r3 = nullptr; // ❌ 引用不能为空
30

31
    // 6. 多级概念
32
    int** pp = &p;      // ✅ 可以有指针的指针
33
    // int&& rr = r;    // ❌ 没有引用的引用（C++11中的&&是右值引用）
34

35
    // 7. sizeof大小
36
    cout << "sizeof(指针) = " << sizeof(p) << endl;    // 4或8字节（地址大小）
37
    cout << "sizeof(引用) = " << sizeof(r) << endl;    // 被引用对象的大小
38

39
    // 8. 安全性
40
    // 野指针问题：
41
    int* dangerous_ptr;  // 未初始化，野指针！
42
    // *dangerous_ptr = 100; // ❌ 可能导致程序崩溃
43

44
    // 引用相对安全：
45
    // int& dangerous_ref;   // 直接编译错误！
46
}

内联函数(Inline)#

1
// 普通函数调用有开销
2
int add(int a, int b) {
3
    return a + b;
4
}
5

6
// 内联函数 - 编译时直接展开代码
7
inline int inline_add(int a, int b) {
8
    return a + b;
9
}
10

11
int main()
12
{
13
    int result1 = add(1, 2);      // 需要函数调用
14
    int result2 = inline_add(1, 2); // 可能直接变成 1 + 2
15

16
    return 0;
17
}

对比宏函数#

1
#define ADD(a, b) ((a) + (b))  // 宏函数 - 容易出错
2

3
inline int add(int a, int b) {  // 内联函数 - 更安全
4
    return a + b;
5
}
6

7
int main()
8
{
9
    int x = 1, y = 2;
10

11
    // 宏的陷阱
12
    cout << ADD(x & y, x | y) << endl;  // 可能不是你期望的结果
13

14
    // 内联函数更安全
15
    cout << add(x & y, x | y) << endl;
16

17
    return 0;
18
}

nullptr-明确的空指针#

与NULL的区别#

NULL实际是一个宏，在cpp中被定义为字面常量0，在c中被定义成五类线指针（void*）的常量；不论采取何种定义，在使⽤空值的指针时，都不可避免的会遇到⼀些麻烦，本想通过f(NULL)调⽤指针版本的f(int*)函数，但是由于NULL被定义成0，调⽤了f(int x)，因此与程序的初衷相悖。f((void*)NULL);调用会报错。
C++11中引⼊nullptr，nullptr是⼀个特殊的关键字，nullptr是⼀种特殊类型的字面量，它可以转换成任意其他类型的指针类型。使⽤nullptr定义空指针可以避免类型转换的问题，因为nullptr只能被隐式地转换为指针类型，⽽不能被转换为整数类型。

1
#ifndef NULL
2

3
#ifdef __cplusplus
4

5
   #define NULL 0
6

7
 #else
8

9
   #define NULL ((void *)0)
10

11
 #endif
12

13
#endif

1
void func(int x) {
2
    cout << "整数版本" << endl;
3
}
4

5
void func(int* ptr) {
6
    cout << "指针版本" << endl;
7
}
8

9
int main()
10
{
11
    func(0);        // 调用整数版本
12
    func(NULL);     // 可能调用整数版本（有歧义）
13
    func(nullptr);  // 明确调用指针版本
14

15
    return 0;

nullptr优势#

1
void nullptr_advantages()
2
{
3
    // 1. 类型安全
4
    int* p1 = nullptr;      // ✅ 正确
5
    // int i = nullptr;     // ❌ 错误！不能将nullptr赋给整数
6

7
    // 2. 明确表达意图
8
    int* ptr1 = 0;          // 这是空指针？还是整数0？
9
    int* ptr2 = nullptr;    // 明确表示空指针！
10

11
    // 3. 模板编程中更安全
12
    template<typename T>
13
    void safe_delete(T* ptr) {
14
        if(ptr != nullptr) {
15
            delete ptr;
16
            ptr = nullptr;  // 避免野指针
17
        }
18
    }
19
}

音乐

音乐

命名空间#

什么是命名空间#

为什么需要命名空间#

三种使用方式#

cin与cout#

基本用法#

优势#

缺省参数#

什么是缺省参数#

规则说明#

函数重载-同名不同参#

什么是函数重载#

重载条件：#

引用-变量别名#

引用是什么#

引用的重要特性#

引用的实用场景#

const引用#

基本概念#

const引用的重要特性#

const引用的实用场景#

综合总结表#

指针与引用的区别#

内联函数(Inline)#

对比宏函数#

nullptr-明确的空指针#

与NULL的区别#

nullptr优势#

文章分享

音乐

C++基础语法

命名空间#

什么是命名空间#

为什么需要命名空间#

三种使用方式#

cin与cout#

基本用法#

优势#

缺省参数#

什么是缺省参数#

规则说明#

函数重载-同名不同参#

什么是函数重载#

重载条件：#

引用-变量别名#

引用是什么#

引用的重要特性#

引用的实用场景#

const引用#

基本概念#

const引用的重要特性#

const引用的实用场景#

综合总结表#

指针与引用的区别#

内联函数(Inline)#

对比宏函数#

nullptr-明确的空指针#

与NULL的区别#

nullptr优势#

文章分享