如何在C++中创建一个类和对象_C++面向对象编程基础-C++-PHP中文网

如何在C++中创建一个类和对象_C++面向对象编程基础

尼克

发布： 2025-09-21 15:00:01

原创

726人浏览过

C++中通过class定义类作为对象的蓝图，使用对象实例化并访问成员，构造函数初始化、析构函数释放资源，继承可扩展基类功能，访问修饰符控制成员权限。

如何在c++中创建一个类和对象_c++面向对象编程基础

C++中创建类和对象，简单来说就是定义蓝图（类），然后根据这个蓝图制造实体（对象）。类是抽象的概念，对象是具体的实例。

解决方案

定义类 (Class Definition): 使用
```
class
```
登录后复制
关键字定义一个类，包含成员变量（数据）和成员函数（方法）。
```
class Dog {
public:
    // 成员变量 (Attributes)
    std::string name;
    int age;

    // 成员函数 (Methods)
    void bark() {
        std::cout << "Woof!" << std::endl;
    }

    void displayInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};
```
登录后复制
这里，
```
Dog
```
登录后复制
类有
```
name
```
登录后复制
和
```
age
```
登录后复制
两个成员变量，以及
```
bark
```
登录后复制
和
```
displayInfo
```
登录后复制
两个成员函数。
```
public
```
登录后复制
关键字表示这些成员可以从类的外部访问。

立即学习“C++免费学习笔记（深入）”；

创建对象 (Object Creation): 使用类名创建对象，就像声明变量一样。

int main() {
    Dog myDog; // 创建一个Dog对象

    // 初始化对象的成员变量
    myDog.name = "Buddy";
    myDog.age = 3;

    // 调用对象的成员函数
    myDog.bark(); // 输出: Woof!
    myDog.displayInfo(); // 输出: Name: Buddy, Age: 3

    return 0;
}

登录后复制

myDog

登录后复制

就是

Dog

登录后复制

类的一个对象。通过

登录后复制

运算符可以访问对象的成员变量和成员函数。

构造函数 (Constructor): 构造函数是一种特殊的成员函数，在创建对象时自动调用，用于初始化对象。

class Dog {
public:
    std::string name;
    int age;

    // 构造函数
    Dog(std::string dogName, int dogAge) {
        name = dogName;
        age = dogAge;
        std::cout << "Dog created!" << std::endl;
    }

    void bark() {
        std::cout << "Woof!" << std::endl;
    }

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

int main() {
    Dog myDog("Max", 5); // 使用构造函数创建对象

    myDog.bark();
    myDog.displayInfo();

    return 0;
}

登录后复制

现在，创建

Dog

登录后复制

对象时，必须提供名字和年龄。构造函数可以有多个，通过不同的参数列表进行重载。

C++中 public, private, protected 访问修饰符有什么区别？

C++中的访问修饰符控制着类成员的访问权限。它们决定了类的哪些成员可以被类的外部访问，哪些只能在类内部访问。

public
登录后复制
: 公共成员。类的外部可以自由访问。就像你在社交媒体上公开的信息，任何人都能看到。
private
登录后复制
: 私有成员。只能在类的内部访问，类的外部无法直接访问。这是你最私密的信息，只有你自己知道。
protected
登录后复制
: 受保护成员。只能在类的内部以及派生类中访问。这就像你的家庭成员才能知道的信息。

选择合适的访问修饰符是面向对象编程中封装的重要组成部分。

private

登录后复制

成员用于隐藏类的内部实现细节，防止外部直接修改，保证数据的安全性。

public

登录后复制

成员提供类的接口，允许外部与对象交互。

protected

登录后复制

成员主要用于继承，允许子类访问父类的某些成员。

北极象沉浸式AI翻译

免费的北极象沉浸式AI翻译 - 带您走进沉浸式AI的双语对照体验

查看详情

例如，假设你有一个

BankAccount

登录后复制

类，其中

balance

登录后复制

（余额）应该是

private

登录后复制

，防止外部直接修改。

deposit

登录后复制

（存款）和

withdraw

登录后复制

（取款）应该是

public

登录后复制

，允许用户进行操作。

class BankAccount {
private:
    double balance;

public:
    BankAccount(double initialBalance) : balance(initialBalance) {}

    void deposit(double amount) {
        balance += amount;
    }

    bool withdraw(double amount) {
        if (amount > balance) {
            return false; // 余额不足
        }
        balance -= amount;
        return true;
    }

    double getBalance() const {
        return balance;
    }
};

登录后复制

什么是C++中的析构函数，它有什么作用？

析构函数是一种特殊的成员函数，与构造函数相反，它在对象被销毁时自动调用。析构函数的名字是类名前面加上一个波浪线

登录后复制

。

析构函数的主要作用是释放对象占用的资源，例如动态分配的内存、打开的文件、网络连接等。如果没有定义析构函数，编译器会提供一个默认的析构函数，但这个默认的析构函数通常不会做任何事情。

class MyClass {
public:
    int* data;

    MyClass(int size) {
        data = new int[size]; // 动态分配内存
        std::cout << "Constructor called" << std::endl;
    }

    ~MyClass() {
        delete[] data; // 释放动态分配的内存
        std::cout << "Destructor called" << std::endl;
    }
};

int main() {
    MyClass obj(10);
    // ... 使用obj
    return 0; // obj超出作用域，析构函数自动调用
}

登录后复制

在这个例子中，

MyClass

登录后复制

的构造函数动态分配了一块内存，析构函数负责释放这块内存。如果忘记在析构函数中释放内存，就会导致内存泄漏。

C++中如何实现类的继承？

继承是面向对象编程的一个重要特性，允许创建一个新的类（派生类），继承现有类（基类）的属性和方法。派生类可以扩展或修改基类的功能。

使用

登录后复制

符号来表示继承关系。

class Animal {
public:
    std::string name;

    void eat() {
        std::cout << "Animal is eating" << std::endl;
    }
};

class Dog : public Animal { // Dog 继承自 Animal
public:
    void bark() {
        std::cout << "Woof!" << std::endl;
    }
};

int main() {
    Dog myDog;
    myDog.name = "Buddy"; // 继承了Animal的name属性
    myDog.eat(); // 继承了Animal的eat方法
    myDog.bark(); // Dog自己的方法

    return 0;
}

登录后复制