C++学习笔记-如何创建/实例化对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

using String = std::string;

class Entity
{
private:
    String m_Name;
public:
    Entity() : m_Name("Unknown") {}
    Entity(const String& name) : m_Name(name) {}

    const String& GetName() const { return m_Name; }
};

int main()
{
    {
        Entity e0;  // 在栈上创建对象
        std::cout << e0.GetName() << std::endl;
    }  // 栈上创建的对象离开作用域后会自动销毁
    
    // 带参数的构造
    Entity e1("Player");
    std::cout << e1.GetName() << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

int main()
{
    Entity* e1 = new Entity();  // 在堆上创建对象
    std::cout << e1->GetName() << std::endl;
    delete e1;  // 堆上创建的对象需要手动销毁
    
    // 带参数的构造
    Entity* e2 = new Entity("Boss");
    std::cout << e2->GetName() << std::endl;
    delete e2;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class LargeObject
{
private:
    int data[1000000];  // 大数组
public:
    LargeObject() {}
};

int main()
{
    // 对于大对象，栈可能无法容纳
    // LargeObject obj;  // 可能导致栈溢出
    
    // 应该在堆上创建
    LargeObject* obj = new LargeObject();
    delete obj;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

class GameManager
{
private:
    Entity* m_Player;
public:
    GameManager()
    {
        m_Player = new Entity("Player");  // 游戏开始时创建
    }
    
    ~GameManager()
    {
        delete m_Player;  // 游戏结束时销毁
    }
    
    Entity* GetPlayer() { return m_Player; }
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class Animal
{
public:
    virtual void MakeSound() = 0;
    virtual ~Animal() = default;
};

class Dog : public Animal
{
public:
    void MakeSound() override { std::cout << "Woof!" << std::endl; }
};

class Cat : public Animal
{
public:
    void MakeSound() override { std::cout << "Meow!" << std::endl; }
};

int main()
{
    // 多态需要使用指针
    Animal* animals[] = {
        new Dog(),
        new Cat()
    };
    
    for (Animal* animal : animals)
    {
        animal->MakeSound();
        delete animal;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <memory>

int main()
{
    // 使用unique_ptr自动管理内存
    std::unique_ptr<Entity> e1 = std::make_unique<Entity>("Smart");
    std::cout << e1->GetName() << std::endl;
    // 不需要手动delete，unique_ptr会自动管理
    
    // 使用shared_ptr共享所有权
    std::shared_ptr<Entity> e2 = std::make_shared<Entity>("Shared");
    {
        std::shared_ptr<Entity> e3 = e2;  // 共享所有权
        std::cout << e3->GetName() << std::endl;
    }  // e3销毁，但e2仍然有效
    std::cout << e2->GetName() << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <chrono>

void StackAllocation()
{
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < 1000000; ++i)
    {
        Entity e;  // 栈分配
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    std::cout << "Stack allocation: " << duration.count() << " microseconds" << std::endl;
}

void HeapAllocation()
{
    auto start = std::chrono::high_resolution_clock::now();
    
    for (int i = 0; i < 1000000; ++i)
    {
        Entity* e = new Entity();  // 堆分配
        delete e;
    }
    
    auto end = std::chrono::high_resolution_clock::now();
    auto duration = std::chrono::duration_cast<std::chrono::microseconds>(end - start);
    std::cout << "Heap allocation: " << duration.count() << " microseconds" << std::endl;
}

1
2
3

// 好的做法
Entity player;
player.DoSomething();

1
2
3

// 现代C++推荐做法
auto player = std::make_unique<Entity>("Player");
player->DoSomething();

1
2
3

// 避免这样做
Entity* player = new Entity("Player");
// ... 容易忘记delete