类(Class)
类是C++中的一个用户定义的数据类型,它定义了一组属性(数据成员)和方法(成员函数),用于表示和操作一类实体的共有特征。类是描述对象的蓝图或模板。在C++中,类的定义是创建自定义数据类型的一种方式,它由一组成员变量(数据成员)和成员函数(方法)组成。下面将详细介绍类的定义,包括语法、访问控制、构造函数与析构函数、成员函数、友元函数等内容。
1. 类的基本语法
class ClassName {
public: // 访问控制
// 数据成员
DataType memberVariable;
// 构造函数
ClassName(parameters);
// 成员函数
ReturnType memberFunction(parameters);
private: // 访问控制
// 私有数据成员或成员函数
protected: // 访问控制
// 保护数据成员或成员函数
};
2. 访问控制
C++中的类提供了三种访问控制修饰符:
- public:公共成员,可以被任何其他代码访问。
- private:私有成员,仅可以在类内部访问,外部无法直接访问。
- protected:保护成员,可以在类内部和派生类中访问,但在外部无法直接访问。
- 示例:
class Example { public: int publicVar; // 公有成员 private: int privateVar; // 私有成员 protected: int protectedVar; // 保护成员 };
3. 数据成员
数据成员是类的属性,用于存储对象的状态。可以是基本数据类型、结构体、类的实例或其他复杂类型。
示例:
class Person {
public:
std::string name; // 姓名
int age; // 年龄
};
4. 构造函数与析构函数
-
构造函数:用于初始化对象的特殊成员函数,名称与类名相同, 可以重载。构造函数可以接受参数,也可以是默认构造函数(无参数构造函数)。
-
析构函数:用于清理对象并释放资源的特殊成员函数,名称与类名相同,但前面加上波浪符
~
。析构函数无法重载,并且不能带参数。
示例:
class Car {
public:
std::string brand;
int year;
// 构造函数
Car(std::string b, int y) : brand(b), year(y) {
std::cout << "Car created: " << brand << " " << year << std::endl;
}
// 析构函数
~Car() {
std::cout << "Car destroyed: " << brand << " " << year << std::endl;
}
};
5. 成员函数
成员函数是类内定义的函数,用于对成员变量进行操作。成员函数可以修改类的私有成员,在类外部通过对象调用时可以访问公共成员。
示例:
class Rectangle {
private:
double width, height;
public:
Rectangle(double w, double h) : width(w), height(h) {}
double area() {
return width * height; // 计算面积
}
};
6. 友元函数
友元函数是可以访问类的私有和保护成员的函数,即使它不是该类的成员。可以将其声明为友元,以实现特定需要。
示例:
class Box {
private:
double width;
public:
Box(double w) : width(w) {}
friend void printWidth(Box b); // 声明友元函数
};
void printWidth(Box b) {
std::cout << "Width: " << b.width << std::endl; // 访问私有成员
}
7. 完整示例
将上述所有内容结合起来,我们可以定义一个完整的类:
#include <iostream>
#include <string>
class Car {
private:
std::string brand;
int year;
public:
// 构造函数
Car(std::string b, int y) : brand(b), year(y) {}
// 成员函数
void displayInfo() {
std::cout << "Brand: " << brand << ", Year: " << year << std::endl;
}
// 友元函数
friend void showBrand(Car c);
};
// 友元函数实现
void showBrand(Car c) {
std::cout << "Brand from friend function: " << c.brand << std::endl;
}
int main() {
Car myCar("Toyota", 2020);
myCar.displayInfo();
showBrand(myCar); // 调用友元函数
return 0;
}
8.基本特性
1.封装:
封装是将数据和操作数据的函数(方法)组合在一起,通过将数据的具体实现细节隐藏在类内部,保持类的内部状态独立于外部世界。封装使用访问控制修饰符(public
、private
、protected
)来限定对类成员的访问。
优点:
- 数据保护:防止未经授权的访问和修改。
- 易于维护:内部实现可以修改而不影响外部代码。
示例:
class BankAccount {
private:
double balance; // 私有数据成员
public:
BankAccount(double initialBalance) : balance(initialBalance) {}
void deposit(double amount) {
if (amount > 0) {
balance += amount; // 允许访问私有成员
}
}
double getBalance() const {
return balance; // 可以读取余额,但不允许直接修改
}
};
2.抽象:
继承是一个类(子类)基于另一个类(父类)创建新类的机制,使得子类可以继承父类的属性和方法。通过继承,子类可以重用代码,扩展功能,以及更好地组织相关的实体。
优点:
- 代码重用:子类可以使用父类的成员。
- 形成类之间的层次结构,增强可扩展性。
示例:
class Animal {
public:
void eat() {
std::cout << "Eating..." << std::endl;
}
};
class Dog : public Animal {
public:
void bark() {
std::cout << "Woof!" << std::endl;
}
};
int main() {
Dog dog;
dog.eat(); // 继承的功能
dog.bark(); // 子类特有的功能
return 0;
}
3.继承:
多态是指同一操作可以作用于不同类型的对象,表现出不同的行为。C++ 通过虚函数和函数重载实现多态性。多态可以分为编译时多态(函数重载和运算符重载)和运行时多态(通过虚函数实现)。
优点:
- 灵活性:同一接口可以产生不同的行为。
- 可扩展性:可以在不更改现有代码的情况下添加新功能。
示例:
class Base {
public:
virtual void show() { // 虚函数
std::cout << "Base class show function." << std::endl;
}
};
class Derived : public Base {
public:
void show() override { // 重写虚函数
std::cout << "Derived class show function." << std::endl;
}
};
void display(Base* b) {
b->show(); // 根据对象类型调用相应的函数
}
int main() {
Base base;
Derived derived;
display(&base); // 输出: Base class show function.
display(&derived); // 输出: Derived class show function.
return 0;
}
4.抽象:
抽象是一个简化过程,它使得只关注对象的必要特征而忽略不相关的细节。通过抽象,可以设计出更高层次的结构,提供简单的接口,将复杂性封装在内部。
抽象可以通过纯虚函数和抽象类来实现。一个类如果包含一个或多个纯虚函数,则称为抽象类,该类无法被实例化。
优点:
- 隐藏复杂性:提供简单的接口,用户无需了解内部细节。
- 支持模块化设计:增强代码的可维护性和可读性。
示例:
class Shape {
public:
virtual void draw() = 0; // 纯虚函数
};
class Circle : public Shape {
public:
void draw() override {
std::cout << "Drawing a circle." << std::endl;
}
};
class Square : public Shape {
public:
void draw() override {
std::cout << "Drawing a square." << std::endl;
}
};
int main() {
Circle circle;
Square square;
Shape* shapes[] = { &circle, &square };
for (Shape* shape : shapes) {
shape->draw(); // 根据具体形状调用相应的 draw 方法
}
return 0;
}
9.总结
类的定义涉及到成员变量、成员函数、构造函数、析构函数和访问修饰符等各个方面。理解这些概念是掌握C++面向对象编程的基础,有助于设计和实现高效、可维护的代码结构。类的四个基本特征(封装、继承、多态、抽象)共同构成了面向对象编程的核心思想,帮助开发者构建模块化、易于维护和扩展的系统。理解这些特性,可以有效地运用C++进行复杂的应用开发。