C++ 面向对象程序设计 14万字总结笔记（四）-阿里云开发者社区

成员对象和封闭类

在C++中，成员对象和封闭类是一种关系，其中封闭类包含一个成员对象作为其成员之一。这种关系可以通过将另一个类的对象声明为封闭类的成员变量来实现。

通过使用成员对象，封闭类可以利用其他类提供的功能，并且可以访问成员对象的成员变量和成员函数。这样，封闭类可以将其他类的功能组合在一起，以实现更复杂的行为。

上例中，如果 CCar类不定义构造函数，则下面的语句会编译出错：

CCar car;

因为编译器不明白 car.tyre该如何初始化。car.engine 的初始化没问题，用默认构造函数即可。

任何生成封闭类对象的语句，都要让编译器明白，对象中的成员对象，是如何初始化的。

具体的做法就是：通过封闭类的构造函数的初始化列表。

成员对象初始化列表中的参数可以是任意复杂的表达式，可以包括函数，变量，只要表达式中的函数或变量有定义就行。

下面是一个示例代码：

class Engine {
public:
    void start() {
        // 引擎启动逻辑
    }
};
class Car {
private:
    Engine engine;
public:
    void startCar() {
        engine.start();
        // 其他汽车启动逻辑
    }
};

在上述示例中，Car类包含一个Engine对象作为其成员变量。通过将Engine对象声明为Car类的成员变量，Car类可以使用Engine类提供的start()函数来启动引擎。在Car类的startCar()函数中，我们可以调用engine对象的start()函数来启动引擎，并执行其他与汽车启动相关的逻辑。

使用成员对象和封闭类的好处是可以实现代码的模块化和可重用性。封闭类可以通过成员对象来获取其他类的功能，并将其组合在一起，从而实现更高级的行为。

需要注意的是，在封闭类的构造函数中，成员对象的构造函数也会被调用。类似地，在封闭类的析构函数中，成员对象的析构函数也会被调用。这确保了成员对象在封闭类的生命周期内正确地进行构造和销毁。

总结一下，成员对象和封闭类是一种关系，其中封闭类包含其他类的对象作为其成员之一。这种关系允许封闭类利用其他类提供的功能，并通过组合来实现更复杂的行为。使用成员对象和封闭类可以实现代码的模块化和可重用性。

下面是一个示例代码：

class Engine {
public:
    void start() {
        // 引擎启动逻辑
    }
};
class Car {
private:
    Engine engine;
public:
    void startCar() {
        engine.start();
        // 其他汽车启动逻辑
    }
};

在封闭类的构造函数中，成员对象的构造函数也会被调用。类似地，在封闭类的析构函数中，成员对象的析构函数也会被调用。这确保了成员对象在封闭类的生命周期内正确地进行构造和销毁。

成员对象和封闭类是一种关系，其中封闭类包含其他类的对象作为其成员之一。这种关系允许封闭类利用其他类提供的功能，并通过组合来实现更复杂的行为。使用成员对象和封闭类可以实现代码的模块化和可重用性。

封闭类构造函数和析构函数的执行顺序

封闭类对象生成时，先执行所有对象成员的构造函数，然后才执行封闭类的构造函数。

对象成员的构造函数调用次序和对象成员在类中的说明次序一致，与它们在成员初始化列表中出现的次序无关。

当封闭类的对象消亡时，先执行封闭类的析构函数，然后再执行成员对象的析构函数。次序和构造函数的调用次序相反。

封闭类的复制构造函数用于创建一个新的对象，该对象是从现有的同类型对象进行复制而来。在复制构造函数中，通常需要对成员对象进行深拷贝，以确保新对象和原对象拥有独立的资源。

下面是一个示例代码：

class MyClass {
private:
    int* data;
public:
    MyClass(const MyClass& other) {
        // 执行深拷贝操作
        data = new int(*other.data);
    }
    // 其他成员函数和构造函数的实现
    ~MyClass() {
        delete data;
    }
};

在上述示例中，我们定义了一个名为MyClass的封闭类，并在其中包含一个动态分配的int类型数据成员data。在复制构造函数中，我们使用new关键字创建了一个新的int对象，并将其初始化为原对象中data指针指向的值的副本。这样可以确保新对象和原对象具有独立的资源。

需要注意的是，在复制构造函数中，还需要处理其他成员变量的复制，以确保新对象拥有与原对象相同的状态。

此外，当定义自定义的复制构造函数时，还应该考虑以下几点：

深拷贝 vs 浅拷贝：如果成员对象本身包含指针或动态分配的内存，复制构造函数应该执行深拷贝，即创建新的资源副本。如果成员对象是只读或不可变的，可以使用浅拷贝。
异常安全性：在执行深拷贝操作时，应保证异常安全性。即使在复制过程中抛出了异常，也要正确处理资源的释放，以防止内存泄漏或资源泄漏。
赋值运算符重载：除了复制构造函数外，还应该重载赋值运算符（=）以支持对象的赋值操作。赋值运算符重载函数的实现与复制构造函数类似。

总结一下，封闭类的复制构造函数用于创建一个新的对象，并以深拷贝的方式复制成员对象和资源。需要对每个成员变量进行适当的复制操作，以确保新对象和原对象具有独立的状态。同时，还应考虑异常安全性和赋值运算符重载的实现。

友元（friends)

友元分为友元函数和友元类两种

友元（friends）是C++中一种特殊的访问权限，它允许某个类或函数访问另一个类的私有成员。通过将一个类或函数声明为另一个类的友元，可以在友元类或函数中直接访问该类的私有成员。

下面是一个示例代码：

class MyClass {
private:
    int privateData;
public:
    MyClass() : privateData(0) {}
    friend class FriendClass;  // 声明FriendClass为MyClass的友元
    void printPrivateData() {
        std::cout << privateData << std::endl;
    }
};
class FriendClass {
public:
    void modifyPrivateData(MyClass& obj, int newData) {
        obj.privateData = newData; // 在FriendClass中直接访问MyClass的私有成员
    }
};
int main() {
    MyClass obj;
    FriendClass friendObj;
    friendObj.modifyPrivateData(obj, 42);
    obj.printPrivateData(); // 输出: 42
    return 0;
}

在上述示例中，我们声明了一个名为MyClass的类，并声明了一个名为FriendClass的类为其友元。在FriendClass中，我们可以直接访问MyClass的私有成员privateData，并进行修改。这得益于FriendClass被声明为MyClass的友元。

需要注意的是，友元关系是单向的，即如果类A声明类B为友元，那么类A的成员函数可以访问类B的私有成员，但类B的成员函数不能自动访问类A的私有成员。如果需要相互访问，需要进行相应的声明。

此外，友元关系是一种破坏封装性的机制，因此应该谨慎使用。合理使用友元可以提供对类的特定部分的访问权限，使得某些操作更方便，但也可能导致代码的可维护性和安全性降低。

总结一下，C++中的友元机制允许一个类或函数访问另一个类的私有成员。通过将一个类或函数声明为另一个类的友元，在友元类或函数中可以直接访问被授权类的私有成员。友元关系是单向的，并且应该谨慎使用，以避免破坏封装性和引入安全问题。

**友元关系可以分为两种类型：友元函数（friend function）和友元类（friend class）。

友元函数：友元函数是在一个类中声明的非成员函数，并且被声明为该类的友元。这意味着友元函数可以直接访问该类的私有成员。通过友元函数，可以将某个外部函数与类建立关联，以便在实现特殊操作或提供其他功能时访问类的私有成员。

class MyClass {
private:
    int privateData;
public:
    friend void friendFunction(MyClass& obj);  // 声明friendFunction为MyClass的友元
    // 其他成员函数和构造函数的实现
};
void friendFunction(MyClass& obj) {
    obj.privateData = 42;  // 在友元函数中直接访问MyClass的私有成员
}

友元类：友元类是在一个类中声明的另一个类，并且被声明为该类的友元。这意味着友元类的成员函数可以直接访问该类的私有成员。通过友元类，可以使得一个类能够访问另一个类的私有成员，从而实现更灵活的设计和组合。

class FriendClass {
public:
    void modifyPrivateData(MyClass& obj) {
        obj.privateData = 42;  // 在FriendClass中直接访问MyClass的私有成员
    }
};
class MyClass {
private:
    int privateData;
public:
    friend class FriendClass;  // 声明FriendClass为MyClass的友元
    // 其他成员函数和构造函数的实现
};

需要注意的是，友元关系应该被谨慎使用，以确保封装性和安全性。友元关系的目的是为了提供灵活性和特殊情况下的访问权限，但过度使用可能会导致代码不易理解和维护。在设计中，应仔细考虑是否真正需要友元关系，并根据具体需求和设计原则进行选择。

友元类之间的关系不能传递，不能继承。

当使用友元关系时，还需要注意以下几点：

友元的范围：友元关系是通过类而不是对象来建立的。一个类的所有对象都可以访问另一个类的私有成员，只要这个类在其声明中将另一个类声明为友元。
友元的传递性：如果类A声明类B为友元，同时类B声明类C为友元，那么类A的成员函数也可以访问类C的私有成员。这种传递性的友元关系使得在复杂的代码结构中，可以通过一系列的友元声明来实现灵活的访问权限。
函数作为友元：除了类之间可以建立友元关系外，函数也可以被声明为类的友元。这样，该函数就可以直接访问该类的私有成员。函数作为友元可以用于提供特定操作或算法所需的访问权限。
友元关系不具备继承性：友元关系不会被继承。即使派生类继承了基类的友元关系，它自己并不具备对基类私有成员的访问权限。
封装和信息隐藏：友元关系破坏了封装性，因此应谨慎使用。友元关系通常用于某些特殊的情况下，例如需要访问私有成员进行优化或实现特殊的操作。

需要明智地使用友元关系，以平衡代码的封装性和灵活性。友元机制可以提供对类的私有成员的访问权限，但也可能导致代码的可维护性和安全性降低。因此，应该仔细考虑并评估在特定情况下使用友元关系的利弊，并确保其使用符合设计原则和需求。

常量成员函数

如果不希望某个对象的值被改变，则定义该对象的时候可以在前面加 const关键字。

常量成员函数（const member function）是指在类中声明的成员函数，在其声明末尾添加const关键字。常量成员函数承诺不会修改对象的状态，因此它们不能修改类的非静态成员变量，也不能调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。

常量成员函数对于处理只读操作或者保护数据的完整性很有用，因为它们可以确保在使用常量对象或通过常量引用/指针访问对象时，不会意外地修改对象的状态。

下面是一个示例代码：

class MyClass {
private:
    int data;
public:
    int getValue() const {
        // 这是一个常量成员函数，不能修改成员变量
        return data;
    }
    void setValue(int value) {
        // 非常量成员函数可以修改成员变量
        data = value;
    }
};

在上述示例中，getValue()被声明为常量成员函数，因此它不能修改data成员变量的值。而setValue()是非常量成员函数，可以修改data成员变量。

当你有一个常量对象时，只能调用常量成员函数来访问其成员变量和执行操作。例如：

int main() {
    const MyClass obj;
    int value = obj.getValue();  // 可以调用常量成员函数
    // obj.setValue(10);  // 错误，常量对象无法调用非常量成员函数
    return 0;
}

需要注意的是，在常量成员函数中不能修改成员变量，也不能调用非常量成员函数，除非这些非常量成员函数也被声明为常量成员函数。

常量成员函数在类中声明的成员函数末尾添加const关键字。它们承诺不会修改对象的状态，因此对于只读操作或保护数据完整性很有用。常量成员函数可以在常量对象或通过常量引用/指针访问对象时调用，并且不能修改成员变量或调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。

当使用常量成员函数时，还需要注意以下几点：

常量对象调用：常量对象只能调用常量成员函数。这是因为常量对象被视为不可修改的，所以只能使用常量成员函数来访问对象的状态。
重载：常量成员函数和非常量成员函数可以进行重载。如果有两个成员函数，一个是常量成员函数，另一个是同名的非常量成员函数，它们可以根据调用对象的常量性来区分。

class MyClass {
public:
    int getValue() const {
        // 常量成员函数
        return 10;
    }
    int getValue() {
        // 非常量成员函数
        return 20;
    }
};
int main() {
    const MyClass obj1;
    MyClass obj2;
    int value1 = obj1.getValue();  // 调用常量成员函数
    int value2 = obj2.getValue();  // 调用非常量成员函数
    return 0;
}

返回类型：常量成员函数可以返回实际值，也可以返回常量引用或指针。如果返回一个非常量类型的实际值，它会被复制到调用者的副本中；如果返回常量引用或指针，则避免了无谓的复制。
mutable关键字：在常量成员函数中，如果希望修改某些成员变量，可以使用mutable关键字来修饰这些成员变量。被mutable修饰的成员变量可以在常量成员函数中被修改。

class MyClass {
private:
    mutable int cacheValue;
public:
    int getValue() const {
        if (cacheValue == 0) {
            // 计算并缓存值
            cacheValue = calculateValue();
        }
        return cacheValue;
    }
    int calculateValue() const {
        // 计算值的逻辑
        return 42;
    }
};

在上述示例中，cacheValue成员变量被声明为mutable，因此可以在常量成员函数中更新它的值。

常量成员函数在保护对象状态的同时，也提供了对只读操作的方便访问。通过合理使用常量成员函数，可以增强代码的安全性和可靠性，并遵循面向对象设计的原则。

常量成员函数是指在类中声明的成员函数末尾添加const关键字。它们只能用于常量对象或通过常量引用/指针访问对象，并且不能修改成员变量或调用非常量成员函数（除非这些成员函数也被声明为常量成员函数）。常量成员函数可以进行重载，返回实际值、常量引用或指针，并且可以使用mutable关键字修饰某些成员变量以在常量成员函数中进行修改。

如果一个成员函数中没有调用非常量成员函数，也没有修改成员变量的值，那么，最好将其写成常量成员函数。

对C++中const的说明

在C++中，const是一个关键字，用于指定对象或变量是只读的，即不可修改。它可以应用于不同的上下文中，包括：

对象和变量声明：通过在变量或对象的声明前加上const关键字，可以将其标记为只读。这意味着一旦被初始化，就不能再修改该对象或变量的值。

const int x = 10; // 声明一个只读的整数常量x
const MyClass obj; // 声明一个只读的MyClass对象

函数参数：使用const关键字修饰函数参数，表示该参数在函数内部是只读的，在函数执行过程中不能被修改。

void print(const std::string& str) {
    // 该函数不能修改str的内容
    std::cout << str << std::endl;
}

成员函数：在成员函数后面添加const关键字，表示该成员函数是一个常量成员函数。常量成员函数承诺不会修改对象的状态，并且只能调用其他常量成员函数或访问类的只读成员变量。

class MyClass {
public:
    void foo() const {
        // 这是一个常量成员函数
        // 不能修改成员变量或调用非常量成员函数
    }
};

返回类型：const关键字也可以用于指定函数或操作符的返回类型是只读的。

const int calculateValue() {
    // 返回一个只读的整数值
    return 42;
}
const MyClass operator+(const MyClass& obj) const {
    // 返回一个只读的MyClass对象
    // 不能修改当前对象或调用非常量成员函数
}

const关键字对于增强代码的可读性、安全性和可维护性非常有帮助。它可以避免意外的修改，保护数据的完整性，并提供了更好的接口设计和封装性。

需要注意的是，使用const关键字并不意味着该对象或变量在内存中是只读的，而仅仅表示在代码中对其进行修改是不被允许的。

当使用const关键字时，还有一些细节和注意事项需要考虑：

可以重载非const和const成员函数：在同一个类中，可以同时定义一个非const版本和一个const版本的成员函数。这样，在调用对象为常量或非常量时，编译器会根据调用对象的常量性选择相应的成员函数。

class MyClass {
public:
    void foo() {
        // 非const 版本的成员函数
    }
    void foo() const {
        // const 版本的成员函数
    }
};

常量对象只能调用常量成员函数：常量对象只能调用常量成员函数，因为常量对象被视为只读对象，不允许修改其状态。但非常量对象可以调用常量成员函数和非常量成员函数。

void someFunction(const MyClass& obj) {
    obj.foo();  // 可以调用常量成员函数
    MyClass nonConstObj;
    nonConstObj.foo();  // 也可以调用非常量成员函数
}

返回类型是const的影响：如果函数返回类型是const，则返回的值通常不能被修改。

const int getValue() {
    return 42;  // 返回的值是只读的
}
int main() {
    const int value = getValue();
    // value = 10;  // 错误，value是只读的
    return 0;
}

指针和引用的const：当使用指针或引用时，const关键字可以应用于指针本身或指向的对象。这样可以限制对指针或引用的修改，或者限制被指向的对象的修改。

int x = 10;
const int* ptr = &x;  // 指向常量的指针，不能通过ptr修改x的值
int y = 20;
int* const ref = &y;  // 指向整数的常量指针，不能通过ref修改指针的指向

mutable成员变量：mutable关键字可以用于修饰类的成员变量，它表示该成员变量可以在常量成员函数中被修改。

class MyClass {
private:
    mutable int count;
public:
    void increment() const {
        ++count;  // 在常量成员函数中可以修改mutable成员变量
    }
};

需要注意的是，const关键字应根据需要和语义正确地应用。它可以提高代码的可读性、安全性和可维护性，但也需要谨慎使用以避免过度使用。正确使用const关键字可以帮助捕捉编程错误、保护数据完整性，并提供更好的接口设计和封装性。

当使用const关键字时，还有一些概念和技巧需要了解：

保证线程安全性：在多线程环境中，常量对象的成员函数是线程安全的。由于常量对象的状态不会被修改，多个线程可以同时访问常量对象的成员函数而无需额外的同步机制。
常量性转换：常量性可以通过类型转换来进行转换。即可以将非常量对象转换为常量对象进行只读操作。这通过将对象引用或指针的类型从非常量改变为常量来实现。

void func(const MyClass& obj) {
    // 可以接受常量对象作为参数并进行只读操作
}
int main() {
    MyClass obj;
    const MyClass& constRef = obj;  // 将非常量对象转换为常量引用
    const MyClass* constPtr = &obj;  // 将非常量对象的地址转换为常量指针
    return 0;
}

const和函数重载：常量性可以用作函数重载的条件之一。如果一个函数的参数是常量对象或常量引用，那么可以重载该函数以提供对常量对象的特殊处理。

class MyClass {
public:
    void process() {
        // 非const 版本的成员函数
    }
    void process() const {
        // const 版本的成员函数
    }
};
int main() {
    MyClass obj;
    const MyClass constObj;
    obj.process();      // 调用非const版本的process函数
    constObj.process(); // 调用const版本的process函数
    return 0;
}

const修饰符位置：在函数声明中，const关键字可以放在成员函数的后面，也可以放在参数列表的后面。这两种形式的意义是相同的，但通常将const关键字放在函数后面更为常见。

class MyClass {
public:
    void process() const;   // const放在函数后面
    void update() const;    // const放在参数列表后面
};
void MyClass::process() const {
    // const成员函数的实现
}
void MyClass::update() const {
    // const成员函数的实现
}

需要根据具体情况正确使用const关键字。合理使用const可以增强代码的安全性、可读性和可维护性，并帮助捕捉编程错误。它提供了一种约束机制，用于指定只读操作和不会修改对象状态的函数，从而增加了代码的健壮性和可靠性。

常量成员函数的重载

在C++中，常量成员函数可以根据被调用对象的常量性进行重载。这意味着可以定义一个非常量版本和一个常量版本的成员函数，分别用于处理常量对象和非常量对象。

下面是一个示例代码：

class MyClass {
public:
    void foo() {
        // 处理非常量对象的逻辑
        std::cout << "Non-const version" << std::endl;
    }
    void foo() const {
        // 处理常量对象的逻辑
        std::cout << "Const version" << std::endl;
    }
};
int main() {
    MyClass obj1;
    const MyClass obj2;
    obj1.foo();  // 调用非常量版本的foo函数
    obj2.foo();  // 调用常量版本的foo函数
    return 0;
}

在上述示例中，MyClass类定义了两个名为foo()的成员函数，一个是非常量版本，另一个是常量版本。当调用非常量对象obj1的foo()函数时，会调用非常量版本；而当调用常量对象obj2的foo()函数时，会调用常量版本。

通过使用常量成员函数的重载，可以根据对象的常量性来选择合适的操作方式。这样可以保证对常量对象的只读操作以及非常量对象的修改操作都能得到正确的处理。

需要注意的是，常量成员函数的重载不仅与常量性有关，还与函数的参数类型和数量相关。因此，在进行函数重载时，需要确保函数的签名（包括参数类型、常量性等）是不同的。

总结一下，常量成员函数可以根据对象的常量性进行重载，以提供对常量对象和非常量对象的不同处理。通过合理使用常量成员函数的重载，可以保证对象在不同常量性下得到适当的操作，并增加代码的灵活性和可读性。

mutable成员变量（可以在const成员函数中修改的成员变量）

可以在const成员函数中修改的成员变量

在C++中，mutable关键字用于修饰类的成员变量，它表示该成员变量可以在常量成员函数中被修改，即使这些函数通常是不允许修改对象状态的。

下面是一个示例代码：

class MyClass {
private:
    mutable int count;
public:
    void increment() const {
        ++count;  // 在常量成员函数中可以修改mutable成员变量
    }
};

在上述示例中，count成员变量被声明为mutable，这意味着即使在常量成员函数（如increment()）中，也可以对其进行修改。默认情况下，常量成员函数是不允许修改对象的状态的，但使用mutable关键字可以打破这个限制。

mutable关键字适用于那些在实现细节中需要跟踪或缓存信息的成员变量。例如，在某个类中计算并缓存某个值，而不希望每次调用时都重新计算，可以使用mutable来标记该成员变量。

需要注意以下几点：

mutable只能应用于非静态成员变量，因为静态成员变量是与类而不是对象相关联的。
mutable成员变量的修改仅限于同一对象内部，并不会影响其他对象的状态。
尽管mutable允许在常量成员函数中修改变量，但仍应该谨慎使用。这是因为常量成员函数通常被认为是不会引起对象状态变化的，因此对于需要修改的情况，最好考虑其他可行的设计方案。

总结一下，mutable关键字用于修饰类的成员变量，表示该成员变量可以在常量成员函数中被修改。它在某些情况下提供了更灵活的设计选择，但也应该谨慎使用，以避免滥用导致代码逻辑混乱或违背设计原则。

运算符重载

在数学上，两个复数可以直接进行+、-等运算。但在C++中，直接将+或-用于复数对象是不允许的。

• 有时会希望，让对象也能通过运算符进行运算。这样代码更简洁，容易理解。

• 例如：complex_a和complex_b是两个复数对象；求两个复数的和, 希望能直接写：

complex_a + complex_b

在数学上，两个复数可以直接进行+、-等运算。但在C++中，直接将+或-用于复数对象是不允许的。

• 有时会希望，让对象也能通过运算符进行运算。这样代码更简洁，容易理解。

• 例如：complex_a和complex_b是两个复数对象；

求两个复数的和, 希望能直接写：

complex_a + complex_b

运算符重载（Operator Overloading）是一种特性，允许我们重新定义已有的运算符的行为，以适应自定义类型的操作。在编程语言中，运算符通常只能用于内置类型或标准库提供的类型，但通过运算符重载，我们可以为自定义类型赋予相应的运算符行为。

在大多数面向对象编程语言中，如C++、Python和Java，都支持运算符重载。不同的语言可能对运算符重载的实现方式有所区别。

以C++为例，通过在类中定义特殊的成员函数，可以实现对运算符的重载。例如，当我们创建一个名为"Vector"的自定义类时，可以重载"+"运算符来执行向量的加法操作：

class Vector {
public:
    int x, y;
    Vector(int x, int y) : x(x), y(y) {}
    Vector operator+(const Vector& v) {
        return Vector(x + v.x, y + v.y);
    }
};
int main() {
    Vector v1(1, 2);
    Vector v2(3, 4);
    Vector result = v1 + v2;
    // result.x = 1+3 = 4, result.y = 2+4 = 6
    return 0;
}

在上述示例中，通过重载"+“运算符，我们可以直接使用”+"操作符来对两个Vector对象进行加法运算。

需要注意的是，在进行运算符重载时，要遵循一些约定和规则，以确保正确的行为。这包括运算符的参数类型、返回类型、操作数数量等。

当进行运算符重载时，我们可以重载多个不同的运算符，并给它们赋予适合自定义类型的行为。以下是一些常见的运算符，可以在许多编程语言中进行重载：

算术运算符：例如 +、-、*、/ 等。通过重载这些运算符，我们可以定义自定义类型之间的加法、减法、乘法和除法操作。
关系运算符：例如 ==、!=、<、>、<=、>= 等。通过重载这些运算符，我们可以定义自定义类型之间的相等性、大小比较等关系操作。
赋值运算符：通常为 =。重载赋值运算符可以使自定义类型支持对象之间的赋值操作。
下标运算符：通常为 []。通过重载下标运算符，我们可以使自定义类型像数组一样使用下标来访问元素。
函数调用运算符：通常为 ()。重载函数调用运算符使得对象可以像函数一样被调用。
类型转换运算符：通过重载类型转换运算符，我们可以使对象能够隐式或显式地转换为其他类型。

要注意的是，在进行运算符重载时，应遵循一些约定和规则，以确保代码的清晰性和可读性。一些常见的指导原则包括：

不要改变运算符的原始含义，以免引起混淆。
遵循运算符的语义约定，例如加法运算符应进行加法操作。
保持重载的运算符的行为与内置类型的一致性，以避免意外的行为。

此外，不同编程语言可能对运算符重载有自己的规则和限制。在使用时，建议查阅相关文档或参考示例代码，以确保正确地进行运算符重载。

总之，运算符重载使得我们可以为自定义类型赋予特定的运算符行为，提供更灵活、直观的代码编写方式，并增强代码的可读性和可维护性。

运算符重载的实质是函数重载

可以重载为普通函数，也可以重载为成员函数

把含运算符的表达式转换成对运算符函数的调用。

把运算符的操作数转换成运算符函数的参数。

运算符被多次重载时，根据实参的类型决定调用哪个运算符函数

运算符重载示例

下面是几个在C++中进行运算符重载的示例：

加法运算符重载：

#include <iostream>
class Vector {
public:
    int x, y;
    Vector(int x, int y) : x(x), y(y) {}
    Vector operator+(const Vector& v) {
        return Vector(x + v.x, y + v.y);
    }
};
int main() {
    Vector v1(1, 2);
    Vector v2(3, 4);
    Vector result = v1 + v2;
    std::cout << result.x << " " << result.y << std::endl;
    return 0;
}

输出结果：4 6

2. 关系运算符重载：

#include <iostream>
class Date {
public:
    int year, month, day;
    Date(int year, int month, int day) : year(year), month(month), day(day) {}
    bool operator==(const Date& other) {
        return (year == other.year && month == other.month && day == other.day);
    }
    bool operator!=(const Date& other) {
        return !(*this == other);
    }
};
int main() {
    Date d1(2022, 10, 1);
    Date d2(2022, 10, 1);
    if (d1 == d2) {
        std::cout << "Dates are equal" << std::endl;
    } else {
        std::cout << "Dates are not equal" << std::endl;
    }
    return 0;
}

输出结果：Dates are equal

3. 赋值运算符重载：

#include <iostream>
class Point {
public:
    int x, y;
    Point(int x, int y) : x(x), y(y) {}
    Point& operator=(const Point& other) {
        x = other.x;
        y = other.y;
        return *this;
    }
};
int main() {
    Point p1(1, 2);
    Point p2(3, 4);
    p1 = p2;
    std::cout << p1.x << " " << p1.y << std::endl;
    return 0;
}

输出结果：3 4

这些示例演示了如何重载不同类型的运算符，使自定义类型具有相应的行为。在实际使用中，可以根据需要进行更多类型的运算符重载，并根据具体情况来定义运算符的行为。请注意，上述代码只是示例，实际应用中可能需要添加错误处理、边界检查等额外的逻辑。

赋值运算符的重载

有时候希望赋值运算符两边的类型可以不匹配，比如，把一个int类型变量赋值给一个Complex对象，

或把一个 char * 类型的字符串赋值给一个字符串对象,此时就需要重载赋值运算符“=”。赋值运算符“=”只能重载为成员函数。

赋值运算符"="只能作为类的成员函数进行重载。在C++中，赋值运算符的重载函数必须是一个成员函数，并且没有返回类型。

如果想要实现不同类型之间的赋值操作，可以使用类型转换构造函数（或转换运算符）来实现类型的隐式转换。然后再通过重载赋值运算符来执行相应的赋值操作。

以下是一个示例，展示了将int类型的变量赋值给Complex对象的情况：

#include <iostream>
class Complex {
public:
    double real, imag;
    Complex(double real = 0.0, double imag = 0.0) : real(real), imag(imag) {}
    // 转换构造函数
    Complex(int value) : real(value), imag(0.0) {}
    // 赋值运算符重载
    Complex& operator=(const Complex& other) {
        if (this == &other) {
            return *this;
        }
        real = other.real;
        imag = other.imag;
        return *this;
    }
};
int main() {
    int intValue = 5;
    Complex complexObj;
    complexObj = intValue;  // 将int类型的变量赋值给Complex对象
    std::cout << complexObj.real << " + " << complexObj.imag << "i" << std::endl;
    return 0;
}

在上述示例中，通过定义Complex类的转换构造函数，我们可以将int类型的值隐式转换为Complex对象。然后，在赋值运算符重载函数中，我们可以将右侧的Complex对象的成员变量值赋给当前对象。

需要注意的是，在进行类型转换时，应该确保转换是合理和安全的，并且不会导致数据丢失或意外行为。同时，赋值运算符的行为应符合预期，确保正确处理各种边界情况。

总结起来，通过利用类型转换构造函数和赋值运算符重载，我们可以实现不同类型之间的赋值操作，提供更灵活的代码编写方式，以适应特定需求。

浅拷贝和深拷贝

浅拷贝和深拷贝是在对象复制过程中涉及的两个概念，用于描述如何复制对象及其数据。

浅拷贝（Shallow Copy）：
浅拷贝是指将一个对象的值复制到另一个对象，但仅复制对象本身的成员变量，而不复制动态分配的资源。这意味着，对于指向内存资源（如堆内存）的指针成员变量，仅复制指针的值，而不创建新的资源副本。因此，原始对象和副本对象将共享同一块内存。
示例：

#include <iostream>
class MyString {
public:
    char* data;
    MyString(const char* str = nullptr) {
        if (str != nullptr) {
            int length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        } else {
            data = nullptr;
        }
    }
    // 拷贝构造函数（浅拷贝）
    MyString(const MyString& other) {
        data = other.data;  // 仅复制指针的值
    }
};
int main() {
    MyString original("Hello");
    MyString copy(original);  // 调用拷贝构造函数（浅拷贝）
    original.data[0] = 'X';  // 修改原始对象的数据
    std::cout << "Original: " << original.data << std::endl;  // 输出：Xello
    std::cout << "Copy: " << copy.data << std::endl;  // 输出：Xello（共享同一块内存）
    return 0;
}

在上述示例中，浅拷贝的拷贝构造函数仅复制指针的值，这意味着原始对象和副本对象将共享相同的data指针，即它们指向同一块内存。如果修改了其中一个对象的data数据，会影响另一个对象。

2. 深拷贝（Deep Copy）：

深拷贝是指将一个对象及其相关资源复制到另一个对象，包括动态分配的内存资源。深拷贝创建了一个新的独立对象，其中包含与原始对象完全相同的数据，但是它们使用不同的内存空间。因此，对其中一个对象进行修改不会影响另一个对象。

示例：

#include <iostream>
class MyString {
public:
    char* data;
    MyString(const char* str = nullptr) {
        if (str != nullptr) {
            int length = std::strlen(str);
            data = new char[length + 1];
            std::strcpy(data, str);
        } else {
            data = nullptr;
        }
    }
    // 深拷贝的拷贝构造函数
    MyString(const MyString& other) {
        if (other.data != nullptr) {
            int length = std::strlen(other.data);
            data = new char[length + 1];
            std::strcpy(data, other.data);
        } else {
            data = nullptr;
        }
    }
    // 深拷贝的赋值运算符重载
    MyString& operator=(const MyString& other) {
        if (this == &other) {  // 检查自我赋值
            return *this;
        }
        delete[] data;  // 释放原有资源
        if (other.data != nullptr) {
            int length = std::strlen(other.data);
            data = new char[length + 1];
            std::strcpy(data, other.data);
        } else {
            data = nullptr;
        }
        return *this;
    }
};
int main() {
    MyString original("Hello");
    MyString copy(original);  // 调用深拷贝的拷贝构造函数
    original.data[0] = 'X';  // 修改原始对象的数据
    std::cout << "Original: " << original.data << std::endl;  // 输出：Xello
    std::cout << "Copy: " << copy.data << std::endl;  // 输出：Hello（独立的内存空间）
    return 0;
}

在上述示例中，深拷贝的拷贝构造函数和赋值运算符重载会创建一个新的data数组，并将原始对象的数据复制到其中。这样，原始对象和副本对象将使用不同的内存空间，修改其中一个对象的data数据不会影响另一个对象。

总结：

浅拷贝只是简单地复制成员变量的值，包括指针的值，而不复制相关资源。深拷贝则复制了对象及其相关资源，创建了一个独立的新对象，避免了对象之间共享资源的问题。在设计类时，需要根据实际需求决定是使用浅拷贝还是深拷贝，并在拷贝构造函数和赋值运算符重载中进行相应的处理。

运算符重载为友元函数

一般情况下，将运算符重载为类的成员函数，是较好的选择。

但有时，重载为成员函数不能满足使用要求，重载为普通函数，又不能访问类的私有成员，所以需要将运算符重载为友元。

在C++中，运算符重载既可以作为成员函数进行重载，也可以作为友元函数进行重载。通过将运算符重载声明为友元函数，我们可以访问类的私有成员变量，并且不需要通过类的对象来调用运算符。

下面是一个示例，展示了如何将加法运算符"+"重载为友元函数：

#include <iostream>
class Complex {
public:
    double real, imag;
    Complex(double real = 0.0, double imag = 0.0) : real(real), imag(imag) {}
    // 声明友元函数
    friend Complex operator+(const Complex& c1, const Complex& c2);
};
// 定义友元函数
Complex operator+(const Complex& c1, const Complex& c2) {
    return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
int main() {
    Complex c1(1.0, 2.0);
    Complex c2(3.0, 4.0);
    Complex result = c1 + c2;  // 调用友元函数
    std::cout << "Real: " << result.real << ", Imaginary: " << result.imag << std::endl;
    return 0;
}

在上述示例中，我们将加法运算符"+"声明为Complex类的友元函数。这样，我们可以在友元函数中直接访问Complex类的私有成员变量real和imag，并执行相应的加法操作。在主函数中，我们通过调用友元函数来执行两个Complex对象的加法运算，并将结果存储在result对象中。

需要注意的是，友元函数声明应放在类的定义中，并且在类的外部定义实际的友元函数。这样可以确保友元函数能够访问类的私有成员变量。

总结起来，通过将运算符重载声明为友元函数，我们可以直接访问类的私有成员变量，并实现对自定义类型的运算符重载。友元函数提供了一种更灵活的方式来定义运算符重载，尤其在需要访问类的私有成员时非常有用。

运算符重载实例：可变长整型数组

下面是一个示例，展示了如何通过运算符重载创建一个可变长整型数组类，并实现对数组进行加法运算的功能：

#include <iostream>
#include <vector>
class VarIntArray {
private:
    std::vector<int> data;
public:
    VarIntArray() {}
    VarIntArray(std::initializer_list<int> list) : data(list) {}
    // 运算符重载：加法运算符
    VarIntArray operator+(const VarIntArray& other) const {
        VarIntArray result;
        size_t maxSize = std::max(data.size(), other.data.size());
        for (size_t i = 0; i < maxSize; i++) {
            int value1 = (i < data.size()) ? data[i] : 0;
            int value2 = (i < other.data.size()) ? other.data[i] : 0;
            result.data.push_back(value1 + value2);
        }
        return result;
    }
    void print() const {
        for (int num : data) {
            std::cout << num << " ";
        }
        std::cout << std::endl;
    }
};
int main() {
    VarIntArray arr1 = {1, 2, 3};
    VarIntArray arr2 = {4, 5, 6, 7};
    VarIntArray result = arr1 + arr2;
    arr1.print();       // 输出：1 2 3
    arr2.print();       // 输出：4 5 6 7
    result.print();     // 输出：5 7 9 7
    return 0;
}

在上述示例中，我们定义了一个VarIntArray类来表示可变长整型数组。通过使用std::vector来存储实际的数组数据。在构造函数中，我们使用了std::initializer_list来接受初始化列表，方便创建对象时传递初始值。

然后，我们重载了加法运算符"+"，使得两个VarIntArray对象可以通过加法运算进行相加。在重载函数中，我们根据两个数组长度的较大值，遍历对应位置上的元素，将其相加并添加到结果数组中。

最后，在主函数中，我们创建了两个VarIntArray对象arr1和arr2，并使用加法运算符将它们相加，将结果存储在result对象中，然后分别输出三个对象的内容。

通过运算符重载，我们可以使自定义类型具有与内置类型类似的行为，提供更直观和灵活的操作方式。对于可变长数组这样的类，通过重载加法运算符，可以很方便地实现数组的合并操作。

流插入运算符流提取运算符的重载

流插入运算符和流提取运算符是C++中常用的运算符重载之一，它们分别用于将自定义类型的对象插入到输出流中和从输入流中提取对象。

流插入运算符"<<"
流插入运算符重载函数通常返回一个std::ostream&类型，并接受两个参数：一个是要输出的流对象（如std::ostream），另一个是要插入到流中的自定义类型对象。在重载函数中，我们可以根据需要将自定义类型的成员变量以特定的格式插入到输出流中，并返回流对象本身。
以下是一个示例，展示了如何重载流插入运算符：

#include <iostream>
class Point {
public:
    int x, y;
    Point(int x = 0, int y = 0) : x(x), y(y) {}
    // 流插入运算符重载
    friend std::ostream& operator<<(std::ostream& out, const Point& p);
};
// 定义流插入运算符重载函数
std::ostream& operator<<(std::ostream& out, const Point& p) {
    out << "(" << p.x << ", " << p.y << ")";
    return out;
}
int main() {
    Point p(3, 4);
    std::cout << "Point: " << p << std::endl;  // 使用流插入运算符输出自定义类型对象
    return 0;
}

在上述示例中，我们定义了一个Point类来表示二维坐标点。通过将流插入运算符重载声明为友元函数，我们可以在重载函数中直接访问Point类的私有成员变量，并将其以特定的格式插入到输出流中。

在主函数中，我们创建了一个Point对象p，并使用流插入运算符将其插入到std::cout输出流中，将结果打印到控制台上。

2. 流提取运算符">>"

流提取运算符重载函数通常返回一个std::istream&类型，并接受两个参数：一个是要输入的流对象（如std::istream），另一个是要从流中提取的自定义类型对象的引用。在重载函数中，我们可以根据需要从输入流中读取数据，并将其赋值给自定义类型对象的成员变量。

以下是一个示例，展示了如何重载流提取运算符：

#include <iostream>
class Point {
public:
    int x, y;
    Point(int x = 0, int y = 0) : x(x), y(y) {}
    // 流提取运算符重载
    friend std::istream& operator>>(std::istream& in, Point& p);
};
// 定义流提取运算符重载函数
std::istream& operator>>(std::istream& in, Point& p) {
    in >> p.x >> p.y;
    return in;
}
int main() {
    Point p;
    std::cout << "Enter coordinates (x y): ";
    std::cin >> p;  // 使用流提取运算符从输入流中提取自定义类型对象
    std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;
    return 0;
}

在上述示例中，我们同样定义了一个Point类来表示二维坐标点。通过将流提取运算符重载声明为友元函数，我们可以在重载函数中直接访问Point类的私有成员变量，并从输入流中读取数据并赋值给它们。

在主函数中，我们创建了一个Point对象p，并使用流提取运算符从std::cin输入流中提取数据，并将其赋值给p的成员变量。然后，我们将p的坐标打印到控制台上。

通过重载流插入运算符和流提取运算符，我们可以方便地将自定义类型对象插入到输出流中，并从输入流中提取数据赋值给对象的成员变量。这样，我们可以使用标准的输入输出方式与自定义类型对象进行交互。

C++ 面向对象程序设计 14万字总结笔记（四）

成员对象和封闭类

封闭类构造函数和析构函数的执行顺序

友元（friends)

常量成员函数

对C++中const的说明

常量成员函数的重载

mutable成员变量（可以在const成员函数中修改的成员变量）

运算符重载

运算符重载示例

赋值运算符的重载

浅拷贝和深拷贝

运算符重载为友元函数

运算符重载实例：可变长整型数组

流插入运算符流提取运算符的重载

热门文章

最新文章

相关课程

相关电子书

相关实验场景

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

C++ 面向对象程序设计 14万字总结笔记（四）

成员对象和封闭类

封闭类构造函数和析构函数的执行顺序

友元（friends)

常量成员函数

对C++中const的说明

常量成员函数的重载

mutable成员变量（可以在const成员函数中修改的成员变量）

运算符重载

运算符重载示例

赋值运算符的重载

浅拷贝和深拷贝

运算符重载为友元函数

运算符重载实例：可变长整型数组

流插入运算符流提取运算符的重载

热门文章

最新文章

相关课程

相关电子书

相关实验场景