编辑“︁C++ 对象创建”︁（章节）

= C++对象创建 =

== 介绍 ==
在C++中，'''对象创建'''是面向对象编程的核心概念之一。对象是类的实例，通过创建对象，我们可以访问类中定义的成员变量和成员函数。理解对象创建的过程对于掌握C++面向对象编程至关重要。

对象创建主要涉及以下几个方面：
* 对象的声明和定义
* 构造函数和析构函数
* 内存分配方式（栈与堆）
* 对象初始化方法

== 基本对象创建 ==

最简单的对象创建方式是在栈上声明一个对象：

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class Car {
public:
    string brand;
    int year;
};

int main() {
    Car myCar;  // 对象创建
    myCar.brand = "Toyota";
    myCar.year = 2020;
    
    cout << "Brand: " << myCar.brand << ", Year: " << myCar.year << endl;
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Brand: Toyota, Year: 2020
</pre>

在这个例子中，`Car myCar;`语句在栈上创建了一个Car类的对象。对象创建后，我们可以使用点运算符(.)访问其成员。

== 使用构造函数创建对象 ==

构造函数是一种特殊的成员函数，在对象创建时自动调用。它通常用于初始化对象的状态。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class Rectangle {
private:
    int width, height;
public:
    // 构造函数
    Rectangle(int w, int h) {
        width = w;
        height = h;
    }
    
    int area() {
        return width * height;
    }
};

int main() {
    Rectangle rect(5, 3);  // 使用构造函数创建对象
    cout << "Area: " << rect.area() << endl;
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Area: 15
</pre>

== 动态对象创建（堆分配） ==

使用`new`运算符可以在堆上动态创建对象，这种对象需要使用指针来访问，并在不再需要时使用`delete`释放内存。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class Student {
public:
    string name;
    int age;
    
    Student(string n, int a) : name(n), age(a) {}
};

int main() {
    Student* studentPtr = new Student("Alice", 20);  // 动态创建对象
    
    cout << "Name: " << studentPtr->name << ", Age: " << studentPtr->age << endl;
    
    delete studentPtr;  // 释放内存
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Name: Alice, Age: 20
</pre>

== 对象创建的内存分配 ==

对象可以在两种内存区域创建：

<mermaid>
pie
    title 对象内存分配方式
    "栈分配" : 50
    "堆分配" : 50
</mermaid>

=== 栈分配 ===
* 自动内存管理
* 生命周期限于作用域
* 创建速度快
* 语法简单

=== 堆分配 ===
* 手动内存管理
* 生命周期由程序员控制
* 需要`new`和`delete`
* 适用于大型对象或需要延长生命周期的对象

== 对象初始化方法 ==

C++提供了多种初始化对象的方式：

1. 传统构造函数初始化
2. 成员初始化列表
3. 统一初始化（C++11引入）
4. 默认初始化

<syntaxhighlight lang="cpp">
class Point {
    int x, y;
public:
    // 1. 传统构造函数初始化
    Point(int a, int b) {
        x = a;
        y = b;
    }
    
    // 2. 成员初始化列表（更高效）
    Point(int a, int b) : x(a), y(b) {}
    
    // 3. 统一初始化
    Point(int a, int b) : x{a}, y{b} {}
};
</syntaxhighlight>

== 实际应用案例 ==

考虑一个银行账户管理系统，我们需要创建账户对象：

<syntaxhighlight lang="cpp">
#include <iostream>
#include <string>
using namespace std;

class BankAccount {
private:
    string accountNumber;
    double balance;
public:
    BankAccount(string num, double initial) 
        : accountNumber(num), balance(initial) {}
    
    void deposit(double amount) {
        balance += amount;
    }
    
    void withdraw(double amount) {
        if (amount <= balance) {
            balance -= amount;
        } else {
            cout << "Insufficient funds!" << endl;
        }
    }
    
    void display() {
        cout << "Account: " << accountNumber 
             << ", Balance: $" << balance << endl;
    }
};

int main() {
    BankAccount myAccount("123456789", 1000.0);  // 创建账户对象
    myAccount.deposit(500.0);
    myAccount.withdraw(200.0);
    myAccount.display();
    
    return 0;
}
</syntaxhighlight>

'''输出:'''
<pre>
Account: 123456789, Balance: $1300
</pre>

== 对象创建的高级主题 ==

=== 拷贝构造函数 ===
当通过现有对象创建新对象时，会调用拷贝构造函数：

<syntaxhighlight lang="cpp">
class MyClass {
public:
    int value;
    
    // 拷贝构造函数
    MyClass(const MyClass &obj) {
        value = obj.value;
    }
};

int main() {
    MyClass obj1;
    obj1.value = 10;
    
    MyClass obj2 = obj1;  // 调用拷贝构造函数
    cout << obj2.value << endl;  // 输出: 10
    
    return 0;
}
</syntaxhighlight>

=== 移动构造函数（C++11） ===
移动构造函数允许资源的高效转移：

<syntaxhighlight lang="cpp">
class ResourceHolder {
    int* resource;
public:
    // 移动构造函数
    ResourceHolder(ResourceHolder&& other) noexcept 
        : resource(other.resource) {
        other.resource = nullptr;
    }
};
</syntaxhighlight>

== 常见问题与最佳实践 ==

1. '''避免内存泄漏'''：确保每个`new`都有对应的`delete`
2. '''优先使用栈分配'''：除非有特殊需求，否则优先在栈上创建对象
3. '''使用智能指针'''（C++11及以上）：`unique_ptr`和`shared_ptr`可以自动管理内存
4. '''考虑对象生命周期'''：确保对象在使用时有效，不使用后及时销毁
5. '''初始化所有成员变量'''：未初始化的成员变量会导致未定义行为

== 总结 ==

C++中的对象创建是面向对象编程的基础，理解不同的创建方式和内存管理策略对于编写高效、安全的代码至关重要。从简单的栈分配到复杂的动态内存管理，C++提供了灵活的对象创建机制。随着C++标准的演进，现代C++（C++11及以上）还引入了更安全和高效的对象创建方式，如统一初始化和智能指针。

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象基础]]