C++类与对象（2）

在C++中，对象是类的实例。要理解对象，首先需要理解类的定义。以下是对C++对象的详细说明：  

1. 对象的创建

在C++中，对象的创建是一个重要的概念，它涉及到如何实例化一个类，从而根据类的定义生成一个具体的对象。下面将详细说明对象的创建，包括创建方式、构造函数、作用域，以及动态和静态分配等方面。

1. 对象的创建方式

C++中可以通过以下几种方式创建对象：

a. 自动（局部）对象

使用类的名称直接创建对象，这种对象在其作用域结束时自动销毁。

class Car {  
public:  
    std::string model;  
    int year;  

    // 构造函数  
    Car(std::string m, int y) : model(m), year(y) {}  
};  

// 创建局部对象  
void createObject() {  
    Car myCar("Toyota", 2022); // myCar是局部变量  
    std::cout << "Car model: " << myCar.model << ", Year: " << myCar.year << std::endl;  
} // myCar的作用域结束，自动被销毁

 b. 静态对象

静态对象在程序启动时创建，在程序结束时销毁。它的生命周期超出了它的作用域。

class Car {  
public:  
    std::string model;  
    int year;  

    Car(std::string m, int y) : model(m), year(y) {}  
};  

// 静态对象  
void function() {  
    static Car myCar("Honda", 2020); // myCar是静态变量  
    std::cout << "Car model: " << myCar.model << ", Year: " << myCar.year << std::endl;  
} // 程序结束时，静态对象仍然存在

c. 动态对象（堆对象）

使用`new`关键字动态分配内存创建对象。这种方式需要手动释放内存。

class Car {  
public:  
    std::string model;  
    int year;  

    Car(std::string m, int y) : model(m), year(y) {}  
};  

void createDynamicObject() {  
    Car* myCar = new Car("Ford", 2021); // 动态分配内存  
    std::cout << "Car model: " << myCar->model << ", Year: " << myCar->year << std::endl;  
    delete myCar; // 手动释放内存  
}

2. 构造函数

构造函数是用于初始化对象的特殊成员函数。在创建对象时，会自动调用构造函数。

class Car {  
public:  
    std::string model;  
    int year;  

    // 默认构造函数  
    Car() : model("Unknown"), year(0) {}  

    // 带参数的构造函数  
    Car(std::string m, int y) : model(m), year(y) {}  
};  

// 创建对象并调用构造函数  
Car car1; // 调用默认构造函数  
Car car2("BMW", 2022); // 调用带参数的构造函数

3. 拷贝构造函数

当对象被复制时，C++调用拷贝构造函数。可以自定义拷贝构造函数以确保正确复制。

class Car {  
public:  
    std::string model;  
    int year;  

    Car(std::string m, int y) : model(m), year(y) {}  

    // 拷贝构造函数  
    Car(const Car &c) : model(c.model), year(c.year) {  
        std::cout << "Copy constructor called." << std::endl;  
    }  
};  

void createCars() {  
    Car car1("Toyota", 2022);  
    Car car2 = car1; // 调用拷贝构造函数  
}

4. 对象的生命周期

- 局部对象在其作用域结束时自动销毁。
- 静态对象在程序结束时销毁。
- 动态对象需要显式使用`delete`释放内存。

5. 作用域注意事项

考虑对象的作用域非常重要。局部对象在其范围内存活，离开作用域后立刻被销毁。动态对象则需要开发者自行管理内存。

void demonstrateScope() {  
    {  
        Car localCar("Audi", 2023); // 局部对象  
        std::cout << localCar.model << std::endl;  
    } // localCar超出作用域，自动销毁  

    Car* dynamicCar = new Car("Tesla", 2022); // 动态对象  
    std::cout << dynamicCar->model << std::endl;  
    delete dynamicCar; // 手动销毁  
}

6. 总结

对象的创建是理解C++面向对象编程的基础。通过类定义对象后，可以利用构造函数进行初始化。不同的创建方式（局部、静态、动态对象）和对象的生命周期管理都是非常重要的概念，对于编写高效、可靠的程序至关重要。
 

2. 对象的属性和行为

在面向对象编程中，对象的属性和行为是理解和实现类及其实例化的重要概念。以下是对这两个概念的详细说明。

1. 对象的属性

对象的属性是指其状态或特征，通常通过类中的成员变量进行定义。属性可以是各种类型的数据，表示对象的特征或相关信息。属性通常是私有的，以确保隐藏实现细节，并通过公开的访问函数（方法）进行访问。

a. 属性的定义

在类中，属性通常通过数据成员来定义。例如：

class Car {  
private:  
    std::string model; // 汽车型号  
    int year;          // 汽车年份  
    float price;      // 汽车价格  

public:  
    // 构造函数  
    Car(std::string m, int y, float p) : model(m), year(y), price(p) {}  

    // 访问器函数（getter）  
    std::string getModel() const {  
        return model;  
    }  

    int getYear() const {  
        return year;  
    }  

    float getPrice() const {  
        return price;  
    }  
};

b. 属性的封装

封装是面向对象编程的一项重要原则，通过将属性设置为私有，外部代码无法直接访问和修改对象的内部状态。通常通过公共的访问函数（getter和setter）来访问和修改这些属性：

void setPrice(float p) {  
    if (p > 0) {  
        price = p; // 仅允许正数价格  
    }  
}

2. 对象的行为

对象的行为是指对象能够执行的操作，通常通过类中的成员函数来定义。行为体现了对象的功能和能够与其他对象或系统交互的能力。

a. 行为的定义

行为可以实现对象的功能，比如启动、停车、加速等等。在类中，行为通过方法（成员函数）来定义。例如：

class Car {  
private:  
    std::string model;  

public:  
    Car(std::string m) : model(m) {}  

    void start() {  
        std::cout << model << " is starting." << std::endl;  
    }  

    void stop() {  
        std::cout << model << " is stopping." << std::endl;  
    }  

    void accelerate() {  
        std::cout << model << " is accelerating." << std::endl;  
    }  
};

b. 行为的多态性

在C++中，通过虚函数，可以实现多态性，允许后续的子类实现或重写父类的行为。例如：

class Vehicle {  
public:  
    virtual void start() {  
        std::cout << "Vehicle is starting." << std::endl;  
    }  
};  

class Car : public Vehicle {  
public:  
    void start() override { // 重写父类行为  
        std::cout << "Car is starting." << std::endl;  
    }  
};  

void startVehicle(Vehicle* v) {  
    v->start(); // 动态绑定  
}

3. 属性与行为的结合

在实际应用中，对象通过属性和行为结合，形成一个完整的功能实体。属性描述对象的状态，行为则定义对象如何操作这些状态。

class Car {  
private:  
    std::string model;  
    int year;  
    float price;  

public:  
    Car(std::string m, int y, float p) : model(m), year(y), price(p) {}  

    void start() {  
        std::cout << model << " is starting." << std::endl;  
    }  

    void stop() {  
        std::cout << model << " is stopping." << std::endl;  
    }  

    void displayInfo() {  
        std::cout << "Model: " << model << ", Year: " << year << ", Price: " << price << std::endl;  
    }  
};  

// 使用示例  
int main() {  
    Car myCar("Toyota", 2022, 30000);  
    myCar.start();  
    myCar.displayInfo();  
    myCar.stop();  

    return 0;  
}

4. 访问属性和行为

外部代码可以通过实例化对象来访问对象的属性和行为：

Car myCar("Honda", 2019, 27000);  
myCar.start(); // 调用对象行为  
std::cout << "Price: " << myCar.getPrice() << std::endl; // 访问对象属性

5. 总结

对象的属性和行为是面向对象设计的核心概念。属性通过数据成员定义对象的状态，而行为通过成员函数定义对象的功能。通过封装、继承和多态等特性，C++提供了强大的支持来实现复杂的对象模型和操作。理解这些概念对于构建高效、可维护的软件系统至关重要。
 

3. 构造函数和析构函数

构造函数和析构函数是C++面向对象编程中的两个重要概念，它们在对象的生命周期中扮演着关键角色。以下是对这两者的详细说明。

1. 构造函数

构造函数是一种特殊的成员函数，其主要目的是在创建对象时初始化对象的属性。构造函数与类同名，但不返回值（也不返回`void`）。

 a. 构造函数的特征

- 同名：构造函数的名称与类名相同。
- 不返回值：构造函数没有返回值类型，不能返回`void`。
- 自动调用：当创建对象时，构造函数会自动调用。
- 可以重载：可以定义多个构造函数（重载），以支持不同的初始化方式。

b. 构造函数的类型

1. 默认构造函数：没有参数，或所有参数都有默认值的构造函数。

  

class Car {  
public:  
    Car() { // 默认构造函数  
        model = "Unknown";  
        year = 0;  
    }  
};

2. 参数化构造函数：带参数的构造函数。

 

class Car {  
public:  
    std::string model;  
    int year;  

    Car(std::string m, int y) : model(m), year(y) {} // 参数化构造函数  
};

3. 拷贝构造函数：通过复制已有对象来创建新对象的构造函数。其形式为：`ClassName(const ClassName &obj)`。

class Car {  
public:  
    std::string model;  

    Car(const Car &c) : model(c.model) { // 拷贝构造函数  
        std::cout << "Copy constructor called." << std::endl;  
    }  
};

c. 使用构造函数

可以通过直接调用构造函数来创建对象：

Car myCar1; // 调用默认构造函数  
Car myCar2("BMW", 2022); // 调用参数化构造函数  
Car myCar3 = myCar2; // 调用拷贝构造函数

2. 析构函数

析构函数是一种特殊的成员函数，其主要目的是在对象生命周期结束时（即对象被销毁时）执行清理工作，释放资源。析构函数与构造函数类似，但其名称为`~ClassName`。

a. 析构函数的特征

- 同名（带波浪号）：析构函数的名称与类名相同，但前面有一个波浪号（`~`）。
- 不返回值：析构函数没有返回值类型，并且不能返回`void`。
- 自动调用：当对象的生命周期结束时，析构函数会自动调用。
- 没有参数：析构函数不能有参数，因此不能重载。

b. 资源管理

析构函数通常用于释放对象在构造时分配的资源，特别是在分配了动态内存、文件句柄或其他系统资源的情况下。例如，如果在对象中使用了`new`分配内存，则需要在析构函数中释放这些内存。

class Car {  
private:  
    std::string* model; // 动态分配的内存  

public:  
    Car(const std::string &m) {  
        model = new std::string(m); // 动态分配内存  
    }  

    ~Car() {  
        delete model; // 释放内存  
    }  
};

c. 使用析构函数

当对象的生命周期结束时，会自动调用析构函数。例如：

{  
    Car myCar("Toyota"); // 构造函数被调用  
    // 在这里使用myCar  
} // 到这里，myCar超出作用域，析构函数被调用

3. 总结

- 构造函数用于初始化对象的属性，可以有多个重载版本，并在对象创建时自动调用。
- 析构函数用于清理资源和执行任何必要的收尾工作，在对象销毁时自动调用。

- 在设计类时，合理使用构造函数和析构函数可以有效管理对象的生命周期，避免内存泄漏及资源遗漏等问题。特别是在涉及资源分配（如动态内存、文件操作等）时，更加需要小心地管理构造和析构过程。
 

4. 对象的拷贝和赋值

在C++中，对象的拷贝和赋值是两个重要的概念，意思是将一个对象的状态复制到另一个对象。拷贝和赋值的处理涉及到拷贝构造函数和赋值运算符重载。以下是对这两个概念的详细说明。

1. 对象的拷贝

对象的拷贝通常通过拷贝构造函数实现。拷贝构造函数是用于通过已经存在的对象创建新对象的特殊构造函数。

a. 拷贝构造函数

拷贝构造函数的基本形式如下：

ClassName(const ClassName& other);

- `other`是要复制的对象的引用。
- 拷贝构造函数通常用于在以下情况下调用：
  - 创建一个对象并用已存在的对象初始化它。
  - 通过在函数内传递对象参数进行传递（按值传递）。
  - 返回对象的副本。

b. 示例

class Car {  
private:  
    std::string model;  
    int year;  

public:  
    // 参数化构造函数  
    Car(std::string m, int y) : model(m), year(y) {}  

    // 拷贝构造函数  
    Car(const Car &c) : model(c.model), year(c.year) {  
        std::cout << "Copy constructor called." << std::endl;  
    }  

    void display() {  
        std::cout << "Model: " << model << ", Year: " << year << std::endl;  
    }  
};  

int main() {  
    Car original("Toyota", 2022); // 调用参数化构造函数  
    Car copy = original; // 调用拷贝构造函数  

    copy.display(); // 输出拷贝对象的属性  
    return 0;  
}

c. 深拷贝与浅拷贝

- 浅拷贝：默认情况下，C++提供的拷贝构造函数是浅拷贝，仅复制对象的成员，适合用于简单的数据类型。如果对象中包含指向动态分配内存的指针，则深拷贝是必要的。
  
- 深拷贝：在拷贝构造函数中实现深拷贝，确保每个对象有自己独立的内存副本。

class Car {  
private:  
    std::string* model; // 动态分配的内存  

public:  
    // 参数化构造函数  
    Car(std::string m) {  
        model = new std::string(m);  
    }  

    // 拷贝构造函数（深拷贝）  
    Car(const Car &c) {  
        model = new std::string(*(c.model)); // 分配新的内存并复制  
    }  

    ~Car() {  
        delete model; // 释放内存  
    }  
};

2. 对象的赋值

对象的赋值通常通过赋值运算符重载实现。赋值运算符用于将一个对象的状态赋值给另一个已存在的对象。

a. 赋值运算符重载

赋值运算符重载的基本形式如下：

ClassName& operator=(const ClassName& other);

- 注意：必须返回`*this`以支持链式赋值，并且为了避免自我赋值，应先进行检查。
- 通常会先释放当前对象的资源，然后分配新资源。

b. 示例

class Car {  
private:  
    std::string* model;  

public:  
    Car(std::string m) {  
        model = new std::string(m);  
    }  

    // 赋值运算符重载  
    Car& operator=(const Car &c) {  
        if (this == &c) // 检查自我赋值  
            return *this;  

        delete model; // 释放原有资源  
        model = new std::string(*(c.model)); // 拷贝新资源  
        return *this; // 返回当前对象  
    }  

    ~Car() {  
        delete model; // 释放内存  
    }  
};

c. 使用赋值运算符

可以通过赋值运算符赋值给已存在的对象：

int main() {  
    Car car1("Toyota");  
    Car car2("Honda");  

    car2 = car1; // 调用赋值运算符重载  
    return 0;  
}

3. 总结

- 拷贝构造函数用于通过已有对象创建新对象，通常用于对象初始化。
- 赋值运算符重载允许将一个对象的状态赋值给另一个已存在的对象。
- 理解浅拷贝和深拷贝的区别，并在适当的情况下实现它们，可以避免潜在的内存问题和资源泄漏。
- 自定义拷贝构造函数和赋值运算符重载时，应始终注意处理自我赋值和资源管理。
 

5. 对象的作用域

在C++中，对象的作用域指的是对象在程序中可被访问的区域。作用域的概念与对象的生命周期密切相关，因为它决定了对象的创建、使用和销毁的时机。以下是对对象作用域的详细说明。

1. 作用域的类型

对象的作用域通常分为以下几种类型：

a. 块作用域（Block Scope）

在一个代码块（如函数、循环或条件语句）内部定义的对象，只有在该块内可访问。当代码块结束时，对象被销毁。

#include <iostream>  
using namespace std;  

void function() {  
    int x = 10; // x的作用域仅在此函数内  
    cout << "Inside function: " << x << endl;  
}  

int main() {  
    function();  
    // cout << x; // 错误，x在这里不可见  
    return 0;  
}

b. 函数作用域（Function Scope）

在函数内部定义的对象，即使是嵌套在其他块中的，也只在该函数内部可见。它们在函数调用结束时被销毁。

#include <iostream>  
using namespace std;  

void function() {  
    int x = 10; // x的作用域是函数内  
    if (true) {  
        int y = 20; // y的作用域是if块内  
        cout << "Inside if: " << y << endl; // 可以访问y  
    }  
    // cout << y; // 错误，y在这里不可见  
}  

int main() {  
    function();  
    return 0;  
}

c. 类作用域（Class Scope）

类成员的作用域是在类的定义范围内。对象的生命周期在对象或类实例的创建和销毁之间持续。类中的成员可以被方法和友元函数访问。

class Car {  
public:  
    void display() {  
        int speed = 100; // speed的作用域是display方法内  
        cout << "Speed: " << speed << endl;  
    }  
};  

int main() {  
    Car myCar;  
    myCar.display();  
    // cout << speed; // 错误，speed在这里不可见  
    return 0;  
}

d. 全局作用域（Global Scope）

全局对象是在所有函数外部定义的对象，具有全局作用域，可以在整个文件中的任何位置（包括函数内）访问，直到程序结束。

#include <iostream>  
using namespace std;  

int globalVar = 50; // 全局变量  

void function() {  
    cout << "Global variable: " << globalVar << endl;  
}  

int main() {  
    function();  
    cout << "Global variable from main: " << globalVar << endl;  
    return 0;  
}

2. 对象的生命周期与作用域

- 创建：对象在其定义的作用域开始时创建。
- 使用：在其作用域内可被使用或调用。
- 销毁：对象在其作用域结束时被销毁。

3. 栈与堆中的对象

对象可以在栈上或堆上创建，这影响它们的生命周期和作用域：

a. 栈上的对象

- 通过在函数内定义对象（如局部变量）创建。
- 自动管理其生命周期，出作用域时自动销毁。

void function() {  
    int x = 10; // 栈上对象  
} // x在这里被销毁

b. 堆上的对象

- 通过`new`运算符创建，必须手动释放。
- 在整个作用域内一直存在，直到手动删除。

void function() {  
    int* p = new int(10); // 堆上对象  
    cout << *p << endl;  
    delete p; // 手动释放内存  
} // p不再访问

4. 作用域解析运算符

在C++中，可以使用作用域解析运算符`::`来访问全局对象或命名空间中的对象。这对区分同名变量非常有用。

int variable = 100; // 全局变量  

void func() {  
    int variable = 200; // 局部变量  
    cout << "Local variable: " << variable << endl; // 输出局部变量  
    cout << "Global variable: " << ::variable << endl; // 输出全局变量  
}

5. 总结

- 对象的作用域决定了对象在程序中的可见性和访问权限。
- 作用域分为块作用域、函数作用域、类作用域和全局作用域。
- 对象的生命周期与作用域密切相关，预先定义的作用域将决定对象的创建、存储及数据管理方式。
- 理解和正确管理作用域可以有效避免变量冲突和内存泄露等问题。