C++ 面向对象编程

面向对象编程（Object-Oriented Programming, OOP）是C++语言的一个重要特性，它允许开发者以更直观和模块化的方式来设计和构建程序。OOP的四个主要原则是：封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism）和抽象（Abstraction）。

1、封装

封装是将数据和操作数据的方法绑定在一起，形成一个不可分割的整体（即对象）。通过封装，可以隐藏对象的内部实现细节，只对外暴露必要的接口。

C++ 的类一般定义在头文件里

Person.h

#pragma once
#include <string>
#include <iostream>
using namespace std;
class Person
{
protected:
	int number;
	string name;
public:
	void setNumber(int newNumber) {
		number = newNumber;
	}
	int getNumber() {
		return number;
	}
	void setName(string newName) {
		name = newName;
	}
	string getName() {
		return name;
	}
	void say() {
		cout << "hello";
	}
};

#pragma once 程序编译一次

private 修饰的变量为成员属性，成员属性只能通过get、set方法调用 

对象创建和方法调用

#include <string>
#include <iostream>
#include "Person.h"
using namespace std;

void main() {
	Person stu;
	stu.setNumber(10);
	cout << stu.getNumber() << endl;
	stu.say();
}

2、继承

继承允许新的类（子类或派生类）继承现有类（父类或基类）的属性和方法。这有助于代码复用和扩展。

#pragma once
#include "Person.h"
class Student :public Person
{
private:
	double score;

public:

	void setScore(double newScore) {
		score = newScore;
	}

	double getScore() {
		return score;
	}

	string toString() {
		return "[" + to_string(getNumber()) + ","
			+ getName() + "," + to_string(getScore())+"]";
	}

};

Student类继承了Person基类

3、多态

多态允许将父类对象视为子类对象来处理，从而实现接口的动态绑定。C++中的多态通常通过虚函数（virtual function）来实现。

多态实现条件：

1）子类继承父类   

2）子类重写父类方法

3）子类向上转型 

父类Animal

class Animal
{
public:
	virtual void makeSound() {
		cout << "animal sound" << endl;
	}
};

子类 Dog ，并且实现父类方法

class Dog : public Animal
{
public:
	void makeSound() override{
		cout << "dog sound" << endl;
	}

};

子类 Cat ，并且实现父类方法

class Cat : public Animal
{
public:
	void makeSound() override {
		cout << "cat sound" << endl;
	}
};

子类向上转型 

void playSound(Animal& animal) {
	animal.makeSound();
}

int main() {
	Dog dog;
	Cat cat;
	playSound(dog); //输出 dog sound
	playSound(cat); //输出 cat sound
	return 0;
}

makeSound函数在Animal类中声明为虚函数，并在Dog和Cat类中重写。这使得playSound函数可以接收不同类型的Animal对象，并根据对象的实际类型调用相应的makeSound方法。

 4、抽象

抽象是指将复杂系统的实现细节隐藏起来，只暴露其接口或公共行为。在C++中，抽象通常通过抽象基类（包含纯虚函数的类）来实现。

class Shape
{
public:
	virtual void draw() = 0;//纯虚函数
};

class Circle : public Shape
{
public:
	void draw() override {
		cout << "drawing circle" << endl;
	}
};

class Square : public Shape
{
public:
	void draw() override {
		cout << "drawing square" << endl;
	}
};

int main() {
	Shape* shape1 = new Circle();
	Shape* shape2 = new Square();
	shape1->draw();
	shape2->draw();
	return 0;
}

Shape类是一个抽象基类，包含一个纯虚函数draw。Circle和Square类继承自Shape类，并实现了draw方法。