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

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

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

解决方案

1. 定义类 (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++免费学习笔记（深入）”；

2. 创建对象 (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

   类的一个对象。 通过

   .

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

3. 构造函数 (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

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

例如，假设你有一个

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;
}

Dog

类继承了

Animal

类的

name

属性和

eat

方法，并且添加了自己的

bark

方法。

public

关键字表示公有继承，基类的

public

成员在派生类中仍然是

public

。 还有

private

继承和

protected

继承，它们会影响基类成员在派生类中的访问权限。