市场调研大赛搜索引擎优化解释

一、首先要了解构造函数6大类【不是特性】

1. 构造函数 (Constructor)

class MyClass {
public:// 默认构造函数MyClass() : data(0) {}// 带参数构造函数MyClass(int val) : data(val) {}private:int data;
};

2. 析构函数 (Destructor)

class MyClass {
public:~MyClass() {// 清理资源}
};

3. 拷贝构造函数 (Copy Constructor)

class MyClass {
public:// 拷贝构造函数MyClass(const MyClass& other) : data(other.data) {}private:int data;
};

• 拷贝构造函数的参数只有一个且必须使用引用传参，否则 使用传值方式会引发无穷递归调用。
  • 这里的理解可能比较困难。你可以想象，你使用一个带参数的函数，就要先传参再使用函数。下图的Date(const Date d)参数是另一个新的函数const Date d ，为了获得这个const Date d ，就需要构造这个const Date d ，又要传入一个const Date d，反反复复就导致递归了。
• 调用拷贝构造的方式是 MyClass new_object(old_object)或MyClass new_object = old_object的写法 。把旧对象的传入到新的对象里。
• 其过程，如下图
  
• 

4. 拷贝赋值函数 (Copy Assignment Operator)

class MyClass {
public:// 拷贝赋值运算符MyClass& operator=(const MyClass& other) {if (this != &other) {  // 防止自赋值data = other.data;}return *this;}private:int data;
};

• 那么如何区分拷贝构造和拷贝复制呢？
• 如下图：
• 

5. 取地址重载函数 (Address-of Operator)

class MyClass {
public:// 取地址运算符重载MyClass* operator&() {return this;// 返回假地址}
};

6. const 取地址重载函数 (const Address-of Operator)

class MyClass {
public:// const 取地址运算符重载const MyClass* operator&() const {return this;// const同样返回假地址}
};

7、完整示例

#include <iostream>class Example {
public:// 1. 构造函数Example() : data(0) { std::cout << "Default Constructor\n"; }Example(int d) : data(d) { std::cout << "Param Constructor\n"; }// 2. 析构函数~Example() { std::cout << "Destructor\n"; }// 3. 拷贝构造函数Example(const Example& other) : data(other.data) {std::cout << "Copy Constructor\n";}// 4. 拷贝赋值函数Example& operator=(const Example& other) {std::cout << "Copy Assignment\n";if (this != &other) {data = other.data;}return *this;}// 5. 取地址重载Example* operator&() {std::cout << "Non-const Address-of\n";return this;}// 6. const取地址重载const Example* operator&() const {std::cout << "Const Address-of\n";return this;}private:int data;
};int main() {Example e1;          // 默认构造函数Example e2(10);      // 参数构造函数Example e3 = e2;     // 拷贝构造函数e1 = e3;             // 拷贝赋值函数Example* p1 = &e1;   // 非const取地址const Example* p2 = &e2;  // const取地址return 0;
}

关键点说明：

1. 构造函数：对象创建时调用，可以有多个重载版本
2. 析构函数：对象销毁时调用，用于资源清理
3. 拷贝构造函数：用已有对象创建新对象时调用
4. 拷贝赋值函数：已有对象间赋值时调用
5. 取地址重载：通常不需要重载，除非需要特殊行为
6. const版本：为const对象提供操作

二、类的新功能【11特性】

1、default

• 强制生成默认函数的关键字default
• 也就是运行默认实现

class MyClass {
public:MyClass() = default;                      // 默认构造函数MyClass(const MyClass&) = default;       // 默认拷贝构造MyClass& operator=(const MyClass&) = default;  // 默认拷贝赋值~MyClass() = default;                    // 默认析构函数
};

2、delete

• 禁止生成默认函数的关键字delete
• 也就是禁止默认实现
• 例如，要让一个类不能被拷贝，可以用=delete修饰将该类的拷贝构造和拷贝赋值。

class CopyBan
{
public:CopyBan(){}
private:CopyBan(const CopyBan&) = delete;CopyBan& operator=(const CopyBan&) = delete;
};

3、override

• override修饰子类的虚函数。
• 子类继承父类虚函数时，子类是否正确重写了虚函数。没有就会编译错误。

class Base {
public:virtual void foo() { std::cout << "Base::foo\n"; }virtual void bar() const { std::cout << "Base::bar\n"; }
};class Derived : public Base {
public:void foo() override {  // 正确：重写 Base::foostd::cout << "Derived::foo\n";}// void bar() override { ... }  // 错误！签名不匹配（缺少 const）void bar() const override {     // 正确：重写 Base::barstd::cout << "Derived::bar\n";}
};

4、final

4.1、修饰类

• 被final修饰的类叫做最终类，最终类无法被继承。

class NoHeritage final //被final修饰，该类不能再被继承
{//...
};

4.2、修饰虚函数

• 表示该虚函数不能再被重写，如果子类继承后重写了该虚函数则编译报错。

class Base {
public:virtual void foo() final {  // 派生类不能重写 foostd::cout << "Base::foo\n";}
};class Derived : public Base {
public:// void foo() override { ... }  // 错误！foo 是 final
};