1
A a;
2
a = A(10);  // 创建了一个临时对象，并赋值给 a

1
class A {
2
    int x;
3
    const int y;
4
    int &z;
5
public:
6
    A(): z(x), y(1) {
7
        x = 0;
8
    }
9
}

1
A() : x(0), z(x), y(1)
2
        // 成员初始化表
3
{
4

5
}

1
class A
2
{
3
    int x;
4
public:
5
    A();              // 构造函数
6
    ~A();             // 析构函数
7
    ......
8
};
9

10
......
11
void f()
12
{
13
    A a;             // 调用 a 的构造函数 A()
14
    ......
15
}                  // 调用 a 的析构函数 ~A()

1
class A {
2
private:
3
    B b_member;  // b_member 在前
4
    C c_member;  // c_member 在后
5

6
public:
7
    A() {
8
        // ... A 构造函数的代码 ...
9
    }
10
    ~A() {
11
        // ... A 析构函数的代码 ...
12
    }
13
};

1
class A
2
{
3
    int x,y;
4
    char *p;
5
public:
6
    A(char *str)
7
    {
8
        x = 0;
9
        y = 0;
10
        p = new char[strlen(str)+1];
11
        strcpy(p,str);
12
    }
13
    ~A() { delete [ ]p; p = NULL; }
14
    ......
15
    // 其中没有定义拷贝构造函数
16
};

1
A a1("abcd");
2
A a2(a1);    // 调用隐式拷贝构造函数，用 a1 对 a2 进行初始化

1
B(const B& b) : a(b.a) {
2
    z = b.z;
3
}

1
class A {
2
    int x;
3
    char *p;
4
public:
5
    void f() const {
6
        x = 10;           // 错误！const 锁住了 x，不能修改。
7
        p = new char[20]; // 错误！const 锁住了指针 p 本身，不能让它指向新的内存地址。
8

9
        strcpy(p, "abcd"); // 正确！编译器允许这么做。
10
    }
11
};

1
const A my_const_object; // 一个常量对象

1
class A {
2
public:
3
    void f() const { ... } // 常成员函数
4
    void g() { ... }       // 普通成员函数
5
};
6

7
// func 的参数是一个指向常量对象的指针
8
// 这意味着 func 承诺不会通过 pa 来修改它所指向的那个 A 对象
9
void func(const A* pa) {
10
    pa->f();  // 正确！因为 f() 是 const 函数，可以被常量对象调用。
11
    pa->g();  // 错误！因为 g() 是普通函数，编译器担心它会修改对象，所以禁止调用。
12
}

1
class A {
2
    int x, y; // 普通成员变量，每个对象都有一份
3
    static int shared; // 静态数据成员，所有对象共享一份
4

5
public:
6
    void increase_all() { x++; y++; shared++; }
7
    int sum_all() const { return x+y+shared; }
8
    // ...
9
};
10

11
// **关键步骤**：在类外进行定义和初始化
12
int A::shared = 0;

1
// 1. 通过对象调用 (不推荐)
2
A a;
3
a.set_shared(10);
4

5
// 2. 通过类名和作用域解析符::调用 (推荐)
6
A::set_shared(20);
7
cout << A::get_shared() << endl; // 输出 20

1
// 不用友元的、低效的实现方式
2
Vector multiply(const Matrix& m, const Vector& v) {
3
    // ... 检查维度是否匹配 ...
4
    Vector result(m.dimension_row());
5
    for (int i = 0; i < m.dimension_row(); ++i) {
6
        int sum = 0;
7
        for (int j = 0; j < m.dimension_column(); ++j) {
8
            // 每次访问元素都要通过函数调用，效率较低
9
            sum += m.element(i, j) * v.element(j);
10
        }
11
        result.element(i) = sum;
12
    }
13
    return result;
14
}

1
// --- 在 Vector.h (或类似文件) ---
2
class Vector {
3
    // ... 其他成员 ...
4
    // 声明全局函数 multiply 是我的朋友
5
    friend Vector multiply(const Matrix& m, const Vector& v);
6
private:
7
    int *p_data;
8
    int num;
9
};
10

11
// --- 在 Matrix.h (或类似文件) ---
12
// 因为 Matrix 的友元函数 multiply 用到了 Vector，所以需要前向声明 Vector 类
13
class Vector; // 前向声明
14

15
class Matrix {
16
    // ... 其他成员 ...
17
    // 声明全局函数 multiply 是我的朋友
18
    friend Vector multiply(const Matrix& m, const Vector& v);
19
private:
20
    int *p_data;
21
    int row, col;
22
};

1
// --- 在 multiply.cpp (或类似文件) ---
2
Vector multiply(const Matrix& m, const Vector& v) {
3
    // ... 检查维度是否匹配，例如 if (m.col != v.num) ...
4

5
    Vector result(m.row); // 创建结果向量
6

7
    for (int i = 0; i < m.row; ++i) {
8
        int sum = 0;
9
        for (int j = 0; j < m.col; ++j) {
10
            // 因为是友元，所以可以高效地直接访问私有数据！
11
            sum += m.p_data[i * m.col + j] * v.p_data[j];
12
        }
13
        result.p_data[i] = sum; // 同样可以直接访问 result 的私有数据
14
    }
15
    return result;
16
}

1
A& A::operator=(const A& a) {
2
    // 1. 防止自我赋值 (a = a;)
3
    if (this == &a) {
4
        return *this;
5
    }
6

7
    // 2. 释放自己原来的内存空间
8
    delete [] p;
9

10
    // 3. 根据对方的大小，为自己申请一块新的内存
11
    p = new char[strlen(a.p) + 1];
12

13
    // 4. 将对方内存中的“内容”复制到自己的新内存中
14
    strcpy(p, a.p);
15

16
    // 5. 复制其他非指针成员
17
    x = a.x;
18
    y = a.y;
19

20
    // 6. 返回对自己（左值）的引用，以支持链式赋值 (a = b = c;)
21
    return *this;
22
}

1
class String {
2
    char *p;
3
public:
4
    // ...
5
    char& operator[](int i) { // 操作符 "[]" 的重载函数
6
        // 增加安全性检查，这是比普通数组更优秀的地方
7
        if (i >= strlen(p) || i < 0) {
8
            cerr << "下标越界错误\n";
9
            exit(-1);
10
        }
11
        return p[i];
12
    }
13
};