C++类、对象和实例化

Simona_Wu

已于 2024-07-15 17:08:17 修改

阅读量112

点赞数 4

分类专栏： C++基础文章标签： c++ 开发语言

于 2024-07-11 21:23:30 首次发布

本文链接：https://blog.csdn.net/Simona_Wu/article/details/140362269

版权

C++基础专栏收录该内容

22 篇文章 0 订阅

订阅专栏

在C++中，类（Class）、对象（Object）和实例化（Instantiation）是面向对象编程（OOP）的核心概念。

类（Class）

类是用户定义的数据类型，它是对象的蓝图或模板。类定义了对象的属性（成员变量）和行为（成员函数）。

对象（Object）

对象是类的实例。每个对象都有自己的一组属性值。对象是通过类来创建的。

实例化（Instantiation）

实例化是创建类的对象的过程。通过实例化，可以根据类创建具体的对象。

示例代码

#include <iostream>
#include <string>

// 定义一个类
class Person {
private:
    // 私有成员变量
    std::string name;
    int age;

public:
    // 构造函数
    Person(const std::string& name, int age) : name(name), age(age) {}

    // 公有成员函数
    void setName(const std::string& name) {
        this->name = name;
    }

    std::string getName() const {
        return name;
    }

    void setAge(int age) {
        this->age = age;
    }

    int getAge() const {
        return age;
    }

    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    // 实例化对象
    Person person1("Alice", 30);
    Person person2("Bob", 25);

    // 使用对象的成员函数
    person1.display();
    person2.display();

    // 修改对象的属性
    person1.setName("Alicia");
    person1.setAge(31);

    // 显示修改后的属性
    person1.display();

    return 0;
}

实例化对象可以在栈上或堆上进行，具体取决于你如何声明和分配对象。以下是几种常见的实例化对象的方法：

在栈上实例化对象
在堆上实例化对象
使用智能指针实例化对象

1. 在栈上实例化对象

在栈上实例化对象是最常见和最简单的方法。对象在离开作用域时会自动销毁。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : member(value) {
        std::cout << "Constructor called with value: " << member << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called for value: " << member << std::endl;
    }

    void print() const {
        std::cout << "Member value: " << member << std::endl;
    }

private:
    int member;
};

int main() {
    MyClass obj(10);  // 在栈上实例化对象
    obj.print();
    // obj在main函数结束时自动销毁
    return 0;
}

2. 在堆上实例化对象

在堆上实例化对象需要使用 new 运算符，并且需要手动释放内存以避免内存泄漏。

#include <iostream>

class MyClass {
public:
    MyClass(int value) : member(value) {
        std::cout << "Constructor called with value: " << member << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called for value: " << member << std::endl;
    }

    void print() const {
        std::cout << "Member value: " << member << std::endl;
    }

private:
    int member;
};

int main() {
    MyClass* obj = new MyClass(20);  // 在堆上实例化对象
    obj->print();
    delete obj;  // 手动释放内存
    return 0;
}

3. 使用智能指针实例化对象

C++11 引入了智能指针，可以自动管理堆上的对象，避免手动释放内存。常用的智能指针有 std::unique_ptr 和std::shared_ptr。

使用 std::unique_ptr
std::unique_ptr 是独占所有权的智能指针，不能复制，只能移动。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : member(value) {
        std::cout << "Constructor called with value: " << member << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called for value: " << member << std::endl;
    }

    void print() const {
        std::cout << "Member value: " << member << std::endl;
    }

private:
    int member;
};

int main() {
    std::unique_ptr<MyClass> obj = std::make_unique<MyClass>(30);  // 使用std::unique_ptr实例化对象
    obj->print();
    // obj在离开作用域时自动销毁
    return 0;
}

使用 std::shared_ptr
std::shared_ptr 是共享所有权的智能指针，可以被多个指针共享，引用计数为零时自动销毁对象。

#include <iostream>
#include <memory>

class MyClass {
public:
    MyClass(int value) : member(value) {
        std::cout << "Constructor called with value: " << member << std::endl;
    }

    ~MyClass() {
        std::cout << "Destructor called for value: " << member << std::endl;
    }

    void print() const {
        std::cout << "Member value: " << member << std::endl;
    }

private:
    int member;
};

int main() {
    std::shared_ptr<MyClass> obj1 = std::make_shared<MyClass>(40);  // 使用std::shared_ptr实例化对象
    {
        std::shared_ptr<MyClass> obj2 = obj1;  // 共享所有权
        obj2->print();
    }  // obj2离开作用域，不会销毁对象，因为obj1还在作用域内
    obj1->print();
    // obj1在离开作用域时自动销毁
    return 0;
}