C/C++教程
C++面向对象资料入门教程
本文主要是介绍C++面向对象资料入门教程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
概述
本文介绍了C++面向对象的基础概念，包括类和对象的基本理解、成员变量与成员函数、构造函数与析构函数。文章还详细讲解了封装、继承和多态性等重要特性，并提供了多个示例代码来帮助理解。此外，文中还探讨了面向对象编程的设计原则及其应用，为读者提供了全面的C++面向对象编程知识。
C++面向对象基础概念
面向对象编程是现代软件开发的重要基石之一，C++作为一门强大的编程语言，全面支持面向对象的编程范式。本文将介绍C++中面向对象的基础概念，包括类和对象的基本理解、成员变量与成员函数、以及构造函数与析构函数。
类和对象的基本理解
在C++中，类（Class）是对象的蓝图，它定义了一组相关的变量（成员变量）和函数（成员函数），这些变量和函数共同描述了对象的状态和行为。对象（Object）则是类的一个具体实例，它包含了类定义的数据成员和成员函数的具体值。
// 定义一个简单的类
class Car {
public:
// 成员变量
int year;
std::string make;
std::string model;
// 成员函数
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
// 创建一个Car对象
Car myCar;
myCar.year = 2020;
myCar.make = "Toyota";
myCar.model = "Camry";
// 调用成员函数
myCar.displayInfo();
return 0;
}
成员变量与成员函数
成员变量（Member Variables）是类中定义的数据成员，用来存储对象的状态。成员函数（Member Functions）是类定义中的函数，用来描述对象的行为或者状态变化。
class Car {
public:
int year;
std::string make;
std::string model;
void setYear(int y) {
year = y;
}
void setMake(std::string m) {
make = m;
}
void setModel(std::string mod) {
model = mod;
}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Car myCar;
myCar.setMake("Toyota");
myCar.setModel("Camry");
myCar.setYear(2020);
myCar.displayInfo();
return 0;
}
构造函数与析构函数
构造函数（Constructor）是一种特殊的成员函数，用于初始化新创建的对象。它在对象创建时自动调用，名称与类名相同，没有返回类型。
析构函数（Destructor）是一种特殊的成员函数，用于清理和释放对象使用的资源。它在对象被销毁之前自动调用，名称前加一个波浪线（~）。
class Car {
public:
int year;
std::string make;
std::string model;
// 构造函数
Car(int y, std::string m, std::string mod) {
year = y;
make = m;
model = mod;
}
// 析构函数
~Car() {
std::cout << "Car object is being destroyed." << std::endl;
}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
{
Car myCar(2020, "Toyota", "Camry");
myCar.displayInfo();
} // 析构函数在这里被自动调用
return 0;
}
封装
封装是面向对象编程中一个重要的概念，它通过将对象的内部实现细节隐藏起来，只暴露必要的接口，从而增加程序的安全性和可维护性。C++中，封装是通过访问权限来实现的。
私有、保护、公有访问权限
在C++中，成员变量和成员函数可以通过访问权限来声明。这些访问权限包括私有（Private）、保护（Protected）和公共（Public）。
- 私有（Private）：只能在类的内部访问，不可从类的外部访问。
- 保护（Protected）：只能在类及其派生类内部访问。
- 公有（Public）：可以被任何访问到该类的对象所访问。
class Car {
private:
int year;
std::string make;
std::string model;
public:
Car(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
void setYear(int y) {
year = y;
}
void setMake(std::string m) {
make = m;
}
void setModel(std::string mod) {
model = mod;
}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Car myCar(2020, "Toyota", "Camry");
myCar.displayInfo();
// 尝试修改私有变量
myCar.year = 2010; // 编译错误，year为私有成员变量
myCar.setYear(2010); // 正确，通过公有成员函数修改私有变量
myCar.displayInfo();
return 0;
}
作用域解析运算符
作用域解析运算符（::）主要用于访问类中的成员变量和成员函数。它可以在不同的作用域中解析成员，比如在类的内部和外部。
class Car {
private:
int year;
std::string make;
std::string model;
public:
Car(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
void setYear(int y) {
::year = y;
}
void setMake(std::string m) {
::make = m;
}
void setModel(std::string mod) {
::model = mod;
}
void displayInfo() {
::std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Car myCar(2020, "Toyota", "Camry");
myCar.displayInfo();
// 使用作用域解析运算符访问成员变量和成员函数
::Car::setYear(myCar, 2010);
myCar.displayInfo();
return 0;
}
继承
继承是面向对象编程中的另一个核心概念，它允许一个类（子类或派生类）继承另一个类（基类或父类）的属性和行为。这样可以实现代码的重用和扩展。
单继承和多继承
单继承是指一个子类只能有一个直接基类，而多继承是指一个子类可以有多个直接基类。
class Vehicle {
public:
int year;
std::string make;
std::string model;
Vehicle(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
void displayInfo() {
std::cout << "Vehicle: " << make << " " << model << ", Year: " << year << std::endl;
}
};
class Car : public Vehicle {
public:
Car(int y, std::string m, std::string mod) : Vehicle(y, m, mod) {}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Car myCar(2020, "Toyota", "Camry");
myCar.displayInfo();
return 0;
}
多继承示例：
class Engine {
public:
int horsepower;
Engine(int hp) : horsepower(hp) {}
void displayInfo() {
std::cout << "Engine: " << horsepower << " horsepower" << std::endl;
}
};
class Car : public Vehicle, public Engine {
public:
Car(int y, std::string m, std::string mod, int hp) : Vehicle(y, m, mod), Engine(hp) {}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
std::cout << "Engine: " << horsepower << " horsepower" << std::endl;
}
};
int main() {
Car myCar(2020, "Toyota", "Camry", 200);
myCar.displayInfo();
return 0;
}
虚函数与纯虚函数
虚函数（Virtual Function）是一种允许动态绑定的成员函数。在基类中声明虚函数，派生类可以覆盖这些虚函数，以提供更具体的实现。纯虚函数（Pure Virtual Function）是一种特殊的虚函数，它没有具体的实现，但要求派生类必须实现这些函数。
class Vehicle {
public:
int year;
std::string make;
std::string model;
Vehicle(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
virtual void displayInfo() {
std::cout << "Vehicle: " << make << " " << model << ", Year: " << year << std::endl;
}
};
class Car : public Vehicle {
public:
Car(int y, std::string m, std::string mod) : Vehicle(y, m, mod) {}
void displayInfo() override {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Vehicle *myVehicle = new Car(2020, "Toyota", "Camry");
myVehicle->displayInfo();
return 0;
}
纯虚函数示例：
class Engine {
public:
int horsepower;
Engine(int hp) : horsepower(hp) {}
virtual void displayInfo() = 0; // 纯虚函数
};
class GasEngine : public Engine {
public:
GasEngine(int hp) : Engine(hp) {}
void displayInfo() override {
std::cout << "Gas Engine: " << horsepower << " horsepower" << std::endl;
}
};
class ElectricEngine : public Engine {
public:
ElectricEngine(int hp) : Engine(hp) {}
void displayInfo() override {
std::cout << "Electric Engine: " << horsepower << " horsepower" << std::endl;
}
};
int main() {
Engine *engine1 = new GasEngine(200);
engine1->displayInfo();
Engine *engine2 = new ElectricEngine(300);
engine2->displayInfo();
return 0;
}
多态性
多态性（Polymorphism）是面向对象编程中的一个关键特性，它允许通过基类指针或引用调用派生类的成员函数。多态性分为动态绑定和静态绑定。
动态与静态绑定
静态绑定（Static Binding）在编译时确定调用哪个函数，而动态绑定（Dynamic Binding）在运行时确定调用哪个函数。
动态绑定示例：
class Vehicle {
public:
int year;
std::string make;
std::string model;
Vehicle(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
virtual void displayInfo() {
std::cout << "Vehicle: " << make << " " << model << ", Year: " << year << std::endl;
}
};
class Car : public Vehicle {
public:
Car(int y, std::string m, std::string mod) : Vehicle(y, m, mod) {}
void displayInfo() override {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Vehicle *myVehicle = new Car(2020, "Toyota", "Camry");
myVehicle->displayInfo();
return 0;
}
静态绑定示例（编译时绑定）：
class Vehicle {
public:
int year;
std::string make;
std::string model;
Vehicle(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
void displayInfo() {
std::cout << "Vehicle: " << make << " " << model << ", Year: " << year << std::endl;
}
};
class Car : public Vehicle {
public:
Car(int y, std::string m, std::string mod) : Vehicle(y, m, mod) {}
void displayInfo() {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Car myCar(2020, "Toyota", "Camry");
myCar.displayInfo();
return 0;
}
虚函数的使用
虚函数允许通过基类指针或引用调用派生类的成员函数，从而实现动态绑定。
class Vehicle {
public:
int year;
std::string make;
std::string model;
Vehicle(int y, std::string m, std::string mod) : year(y), make(m), model(mod) {}
virtual void displayInfo() {
std::cout << "Vehicle: " << make << " " << model << ", Year: " << year << std::endl;
}
};
class Car : public Vehicle {
public:
Car(int y, std::string m, std::string mod) : Vehicle(y, m, mod) {}
void displayInfo() override {
std::cout << "Car: " << make << " " << model << ", Year: " << year << std::endl;
}
};
int main() {
Vehicle *myVehicle = new Car(2020, "Toyota", "Camry");
myVehicle->displayInfo();
return 0;
}
虚拟与接口类
虚拟基类（Virtual Base Class）可以解决多继承中的重复继承问题，而接口类（Interface Class）是一种特殊的类，它定义了一组纯虚函数，提供了一组规范化的接口。
抽象类与接口类的应用
抽象类（Abstract Class）是一种不能直接实例化的类，它通常包含一个或多个纯虚函数。接口类是一种特殊的抽象类，它仅包含纯虚函数，没有数据成员。
class Engine {
public:
virtual void displayInfo() = 0;
};
class GasEngine : public Engine {
public:
int horsepower;
GasEngine(int hp) : horsepower(hp) {}
void displayInfo() override {
std::cout << "Gas Engine: " << horsepower << " horsepower" << std::endl;
}
};
class ElectricEngine : public Engine {
public:
int horsepower;
ElectricEngine(int hp) : horsepower(hp) {}
void displayInfo() override {
std::cout << "Electric Engine: " << horsepower << " horsepower" << std::endl;
}
};
int main() {
Engine *engine1 = new GasEngine(200);
engine1->displayInfo();
Engine *engine2 = new ElectricEngine(300);
engine2->displayInfo();
return 0;
}
虚拟基类示例：
class Base {
public:
virtual void displayInfo() = 0;
};
class Derived1 : virtual public Base {
public:
void displayInfo() override {
std::cout << "Derived1" << std::endl;
}
};
class Derived2 : virtual public Base {
public:
void displayInfo() override {
std::cout << "Derived2" << std::endl;
}
};
class Derived3 : public Derived1, public Derived2 {
public:
void displayInfo() override {
Derived1::displayInfo();
Derived2::displayInfo();
}
};
int main() {
Derived3 obj;
obj.displayInfo();
return 0;
}
面向对象编程设计原则
面向对象编程的设计原则是确保软件的可维护性和可扩展性，这些原则包括单一职责原则、开闭原则、里氏替换原则、接口隔离原则、依赖倒置原则和责任链原则。
单一职责原则（SRP）
单一职责原则是指一个类应该只有一个引起它变化的原因。这意味着一个类应该只有一个功能，避免多个职责混合在一起。
class Car {
public:
void drive() {
std::cout << "Driving the car." << std::endl;
}
void park() {
std::cout << "Parking the car." << std::endl;
}
};
class ParkingSystem {
public:
void parkCar(Car car) {
std::cout << "Parking car in the system." << std::endl;
}
};
int main() {
Car myCar;
myCar.drive();
myCar.park();
ParkingSystem parkingSystem;
parkingSystem.parkCar(myCar);
return 0;
}
开闭原则（OCP）
开闭原则是指软件实体（类、模块、函数等）应该对扩展开放，对修改关闭。这意味着在不修改现有代码的情况下，应该能够扩展类的功能。
class Vehicle {
public:
virtual void drive() = 0;
};
class Car : public Vehicle {
public:
void drive() override {
std::cout << "Driving the car." << std::endl;
}
};
class Motorcycle : public Vehicle {
public:
void drive() override {
std::cout << "Driving the motorcycle." << std::endl;
}
};
int main() {
Vehicle *car = new Car();
car->drive();
Vehicle *motorcycle = new Motorcycle();
motorcycle->drive();
return 0;
}
里氏替换原则（LSP）
里氏替换原则是指子类对象应该能够替换基类对象，而不影响程序的正确性。这意味着派生类对象可以在任何基类对象出现的地方使用。
class Shape {
public:
virtual double area() = 0;
};
class Rectangle : public Shape {
public:
int width;
int height;
Rectangle(int w, int h) : width(w), height(h) {}
double area() override {
return width * height;
}
};
class Circle : public Shape {
public:
int radius;
Circle(int r) : radius(r) {}
double area() override {
return 3.14 * radius * radius;
}
};
int main() {
std::vector<Shape*> shapes;
shapes.push_back(new Rectangle(4, 5));
shapes.push_back(new Circle(3));
for (Shape* shape : shapes) {
std::cout << "Area: " << shape->area() << std::endl;
}
return 0;
}
接口隔离原则（ISP）
接口隔离原则是指不应该强迫客户端依赖它们不需要的接口。这意味着应该将接口分解成更小的、更具体的接口，以满足特定客户端的需求。
class Keyboard {
public:
void typeText() {
std::cout << "Typing text." << std::endl;
}
};
class Mouse {
public:
void click() {
std::cout << "Clicking the mouse." << std::endl;
}
};
class Computer {
public:
Keyboard keyboard;
Mouse mouse;
void useKeyboard() {
keyboard.typeText();
}
void useMouse() {
mouse.click();
}
};
int main() {
Computer computer;
computer.useKeyboard();
computer.useMouse();
return 0;
}
依赖倒置原则（DIP）
依赖倒置原则是指抽象不应该依赖于细节，细节应该依赖于抽象。这意味着应该通过接口或抽象类而不是具体类来实现依赖关系。
class Engine {
public:
virtual void start() = 0;
virtual void stop() = 0;
};
class GasEngine : public Engine {
public:
void start() override {
std::cout << "Starting gas engine." << std::endl;
}
void stop() override {
std::cout << "Stopping gas engine." << std::endl;
}
};
class ElectricEngine : public Engine {
public:
void start() override {
std::cout << "Starting electric engine." << std::endl;
}
void stop() override {
std::cout << "Stopping electric engine." << std::endl;
}
};
class Car {
private:
Engine* engine;
public:
Car(Engine* e) : engine(e) {}
void startEngine() {
engine->start();
}
void stopEngine() {
engine->stop();
}
};
int main() {
Engine* gasEngine = new GasEngine();
Car gasCar(gasEngine);
gasCar.startEngine();
gasCar.stopEngine();
Engine* electricEngine = new ElectricEngine();
Car electricCar(electricEngine);
electricCar.startEngine();
electricCar.stopEngine();
return 0;
}
责任链原则（Chain of Responsibility）
责任链原则是指请求可以在责任链上传递，直到有一个对象处理它为止。这意味着请求可以通过多个处理者传递，直到找到一个合适的处理者来处理它。
class Handler {
public:
virtual void handleRequest() = 0;
};
class ConcreteHandler1 : public Handler {
public:
void handleRequest() override {
std::cout << "ConcreteHandler1 handling request." << std::endl;
}
};
class ConcreteHandler2 : public Handler {
public:
void handleRequest() override {
std::cout << "ConcreteHandler2 handling request." << std::endl;
}
};
class Client {
private:
Handler* handler1;
Handler* handler2;
public:
Client(Handler* h1, Handler* h2) : handler1(h1), handler2(h2) {}
void setNextHandler(Handler* nextHandler) {
handler2 = nextHandler;
}
void request() {
handler1->handleRequest();
handler2->handleRequest();
}
};
int main() {
ConcreteHandler1 handler1;
ConcreteHandler2 handler2;
Client client(&handler1, &handler2);
client.request();
client.setNextHandler(&handler2);
client.request();
return 0;
}
通过以上示例和代码演示，我们可以看到C++语言中面向对象编程的各个重要概念和设计原则。这些概念不仅增强了代码的组织和复用，还使得代码更加灵活和易于扩展。通过遵循这些原则，可以编写出更加健壮和可维护的程序。
这篇关于C++面向对象资料入门教程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
怎么获取 APK 文件的 MD5 摘要值-icode9专业技术文章分享10-26
-
20 个每个开发者都应该知道的 TypeScript 技巧 ??10-26
-
C++0基础资料：入门教程与实战指南10-25
-
C++11新特性资料详解：面向初学者的简单教程10-25
-
C++11语法资料入门教程10-25
-
C++11资料：新手入门教程与实践指南10-25
-
C++编程资料入门教程10-25
-
C++编程资料：新手入门教程与实战指南10-25
-
C++高级语法资料入门详解10-25
-
C++基础语法资料：入门级教程与指南10-25
-
C++零基础资料：新手入门完全指南10-25
-
C++内存调试资料详解10-25
-
C++内存管理资料详解：新手入门指南10-25
-
C++数据类型资料详解与应用指南10-25
-
C++数组资料详解：入门教程与实践指南10-25
栏目导航
