C++相关

#include <iostream>
using namespace std;

// 1. 函数重载
void print(int x) {
    cout << "Integer: " << x << endl;
}

void print(double x) {
    cout << "Double: " << x << endl;
}

void print(const string& s) {
    cout << "String: " << s << endl;
}
> 符号表如何支持函数重载？
在支持重载的语言（如 C++）中，符号表不会把同名函数合并成一个条目，而是为每个不同的函数签名单独存储一条记录，并将它们组织成一个“重载集合”，用的时候根据实参的类型和数量等样进行匹配，找到最匹配的函数调用。

// 2. 函数模板（泛型）
template<typename T>
void printGeneric(const T& value) {
    cout << "Generic: " << value << endl;
}

// 3. 运算符重载
class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}

    Point operator+(const Point& other) const {
        return Point(x + other.x, y + other.y);
    }
};

int main() {
    print(42);           // 调用 print(int)
    print(3.14);         // 调用 print(double)
    print("Hello");      // 调用 print(string)

    printGeneric(100);   // 编译时生成 printGeneric<int>
    printGeneric(2.5);   // 生成 printGeneric<double>

    Point p1(1, 2), p2(3, 4);
    Point p3 = p1 + p2;  // 使用重载的 +
    cout << "Point: (" << p3.x << ", " << p3.y << ")" << endl;

    return 0;
}

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void speak() {
        cout << "Animal speaks" << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        cout << "Dog barks: 汪汪！" << endl;
    }
};

int main() {
    Dog dog;
    Animal* ptr = &dog;  // 基类指针指向派生类对象

    ptr->speak();  // 输出 Dog barks: 汪汪！
    return 0;
}

void makeAnimalSpeak(Animal& animal) {
    animal.speak();  // 动态绑定
}

int main() {
    Dog dog;
    makeAnimalSpeak(dog);  // 输出：Dog barks: 汪汪！
    return 0;
}

int main() {
    Dog dog;
    Animal a = dog;  // 把 Dog 对象赋值给 Animal 对象（会发生“对象切片”）

    a.speak();  // 输出 Animal speaks
    return 0;
}

int& ref;     // 错误！未初始化
int a = 5, b = 10;
int& ref = a;
ref = b;      // 注意：这是赋值！不是重新绑定！a 变成 10，ref 仍绑定 a，此时a 和 ref 都是 10

class MyInt {
    int value;
public:
    MyInt(int v) : value(v) {}
    
    // 返回引用，支持链式赋值
    MyInt& operator=(const MyInt& other) {
        if (this != &other) {  // 自赋值检查
            value = other.value;
        }
        return *this;  // 返回当前对象的引用
    }
};

MyInt a(1), b(2), c(3);
a = b = c;  // 链式赋值：b=c 返回 b 的引用，再赋给 a

int& getRef() {
    int x = 10;
    return x;  // 错误！x 是局部变量，函数结束后销毁
}

vector<string> names = {"Alice", "Bob", "Charlie"};

// 使用引用遍历，避免拷贝字符串
for (const string& name : names) {
    cout << name << endl;
}

// 或使用 auto&
for (auto& name : names) {
    name += " (modified)";  // 如果想修改原元素
}

const int& cref = x;  // cref 是 x 的常引用
cref = 20;            // 错误！不能通过 cref 修改 x

double getValue() {
    return 3.14;
}

const double& r = getValue();  // 合法！临时对象生命周期延长到 r 结束
cout << r;  // 输出 3.14

const string& s = "hello";  // 不拷贝字符串

const string& result = getPrefix() + getName() + getSuffix();
// 临时 string 对象被 const 引用延长生命周期

for (const auto& item : vec) { ... }  // 避免拷贝，安全高效

10;                // 字面量，右值
x + 1;             // 表达式结果，右值
string("hello");   // 临时 string 对象，右值

//类型&& 右值引用名 = 右值;
int&& rref = 10;           // 10 是右值，rref 是它的右值引用
int&& rref2 = 5 + 3;       // 表达式结果是右值
string&& sref = string("临时字符串");  // 绑定临时 string 对象

// std:move(x) 将左值转换为右值引用，触发移动语义
MyString s1("hello");
MyString s2 = std::move(s1);  // 告诉编译器：“s1 可以被移动了”

cout << s1.data;  // 可能是 nullptr！s1 处于“有效但不可用”状态

class Animal {
protected:
    string name;
public:
    Animal(string n) : name(n) {}
    void eat() { cout << name << " 在吃东西" << endl; }
};

// Dog 继承 Animal，继承方式为 public
class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}  // 调用基类构造函数
    void bark() { cout << name << " 汪汪叫！" << endl; }
};

int main() {
    Dog d("小黄");
    d.eat();   // 继承自 Animal
    d.bark();  // Dog 自己的方法
    return 0;
}

class Base {
public:
    Base() { cout << "Base 构造\n"; }
    ~Base() { cout << "Base 析构\n"; }
};

class Member {
public:
    Member() { cout << "Member 构造\n"; }
    ~Member() { cout << "Member 析构\n"; }
};

class Derived : public Base {
    Member m;
public:
    Derived() { cout << "Derived 构造\n"; }
    ~Derived() { cout << "Derived 析构\n"; }
};

int main() {
    Derived d;
    return 0;
}

class Animal {
public:
    virtual void speak() { cout << "Animal sound\n"; }
    Animal() {  // 构造函数
        // 在这里，vptr 被设置为指向 Animal 的 vtable
    }
};

class Dog : public Animal {
public:
    virtual void speak() override { cout << "汪汪！\n"; }
    Dog() {  // Dog 的构造函数
        // 在这里，vptr 被更新为指向 Dog 的 vtable
    }
};

class Animal {
public:
    virtual void speak() {
        cout << "Animal speak" << endl;
    }

    virtual void speak(string msg) {
        cout << "Animal says: " << msg << endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {  // ✅ 重写 speak()
        cout << "Dog barks" << endl;
    }
    // 注意：speak(string) 被隐藏了！
};

Dog d;
d.speak();           // 输出：Dog barks
// d.speak("hello"); // 编译错误！speak(string) 被隐藏

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

class MyString {
private:
    char* data;  // 指向堆上的字符串

public:
    // 1️⃣ 构造函数
    MyString(const char* str = nullptr) {
        if (str == nullptr || str[0] == '\0') {
            data = new char[1];
            data[0] = '\0';
        } else {
            data = new char[strlen(str) + 1];
            strcpy(data, str);
        }
    }

    // 2️⃣ 析构函数：释放资源
    ~MyString() {
        delete[] data;  // 释放堆内存
        data = nullptr; // 防止悬空（可选）
    }

    // 3️⃣ 拷贝构造函数：深拷贝
    MyString(const MyString& other) {
        if (other.data == nullptr) {
            data = nullptr;
        } else {
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }
    }

    // 4️⃣ 拷贝赋值运算符：深拷贝赋值
    MyString& operator=(const MyString& other) {
        // 自我赋值检查
        if (this == &other) {
            return *this;
        }

        // 先释放旧资源
        delete[] data;

        // 分配新内存，深拷贝
        if (other.data == nullptr) {
            data = nullptr;
        } else {
            data = new char[strlen(other.data) + 1];
            strcpy(data, other.data);
        }

        return *this;
    }

    // 辅助函数：打印
    void print() const {
        cout << (data ? data : "null") << endl;
    }
};

#define MAX(a,b) ((a) > (b) ? (a) : (b))
int x = MAX(i++, j++);  // i 和 j 可能被 ++ 两次！

inline int max(int a, int b) { return a > b ? a : b; }
int x = max(i++, j++);  // 安全，参数只计算一次

friend void Student::show(Address *addr);

class Address{
public:
 Address(char *province, char *city, char *district);
public:
 //将Student类声明为Address类的友元类，Student类中的所有成员函数都可以访问Address类的private成员
 friend class Student;
private:
 char *m_province; //省份
 char *m_city; //城市
 char *m_district; //区（市区）
};

std::unique_ptr<int> u1(new int(10));
// std::unique_ptr<int> u2 = u1;  // 编译错误，不允许拷贝
std::unique_ptr<int> u3 = std::move(u1);

template <typename T>
void swap(T& a, T& b) {
    T temp = a;
    a = b;
    b = temp;
}

template <typename T, typename U>
auto add(T a, U b) -> decltype(a + b) { // auto表示返回值在后面指定，编译器会根据a+b的结果自动推导返回类型
    return a + b;
}

// template <typename T1, typename T2, ...>
// class ClassName {
//     // 使用 T1, T2 等作为类型
// };
template <typename T, int N>
class Array {
    T data[N];
public:
    T& operator[](int index) {
        return data[index];
    }
    int size() { return N; }
};

class MyClass {
public:
    static int count;       // 声明
};
int MyClass::count = 0;     // 定义（C++17 前必需）
// 或 C++17 起：
// inline static int count = 0;

class MyClass {
public:
    static void print() {
        // 不能访问非静态成员
        std::cout << "Static function\n";
    }
};

MyClass::print(); // 无需对象

int *p[4];
int b[12] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
p = b;

int* p[4];

int (*p)(int, int); // 括号不能省略
p = add;
int add(int a, int b) { return a + b; }
int result = p(1, 2);
printf("%d\n", result); // 3

#include <atomic>
std::atomic<int> counter;
counter.fetch_add(1);   // fetch_sub(), fetch_and(), fetch_or()...
counter.load();
counter.store(0);
counter.exchange(0);
counter.compare_exchange_strong(old_value, new_value);  // 如果old_value == counter，则将 counter 设为 new_value
counter.compare_exchange_weak(old_value, new_value);    // 区别：weak 版本允许虚假失败，需要循环
counter.is_lock_free();