C++【5】类与对象（一） 例子演示

c++面向对象编程的基本思想：

C++是一种通用编程语言，支持面向对象编程。面向对象编程（Object-Oriented Programming, OOP）是一种编程范式，它使用“对象”来设计软件和应用程序。在OOP中，现实世界中的事物被抽象为“对象”，每个对象都有其属性（成员变量）和行为（成员函数）。OOP的主要特点包括封装、继承、多态和抽象。

封装（Encapsulation）：封装是指将数据（属性）和操作数据的函数（方法）捆绑到一起，形成一个独立的实体，即对象。这种机制可以隐藏对象的内部实现细节，只通过对象提供的接口与外界交互，增强了代码的安全性和易维护性。

class Car {  
    private:  
        string color;  
        int speed;  
    public:  
        void setColor(string c) { color = c; }  
        void setSpeed(int s) { speed = s; }  
        string getColor() { return color; }  
        int getSpeed() { return speed; }  
};

继承（Inheritance）：继承是从已存在的类派生出新的类，新的类继承了原有类的属性和方法，同时可以增加新的属性和方法或者覆盖父类的方法。继承使得代码重用和复杂性降低成为可能。

class Animal {    //父类  
    public:  
        void eat() {  
            cout << "Animal is eating" << endl;  
        }  
};  
  
class Dog : public Animal {    //子类：狗属于动物的一种，继承父类Animal
    public:  
        void bark() {  
            cout << "Dog is barking" << endl;   //狗正在叫
        }  
};

 多态（Polymorphism）：多态是指允许一个接口多种形态存在的特性。在C++中，多态主要通过继承和虚函数实现。这样我们可以用一个统一的接口处理不同的对象，而具体对象的行为可以在运行时确定。

抽象（Abstraction）：抽象意味着只展现对象的必要信息，而隐藏不必要的详细信息。在C++中，我们可以通过抽象类或者接口实现。抽象类是一种不能被实例化的类，它只用来作为其他类的基类，包含至少一个纯虚函数。接口是一种完全抽象的类，只包含纯虚函数。

class Shape {    // 抽象类  
    public:  
        virtual double getArea() = 0;  // 纯虚函数  
};

 这些特性使得面向对象编程更加接近现实世界，能够更自然地描述现实问题，提高了代码的可读性、可维护性和可重用性。

C++是一种通用编程语言，支持面向对象编程。在C++中，类（class）是一种用于定义对象结构和行为的基本构造。类是面向对象编程的核心，它可以用来创建对象，封装数据和操作数据的方法。下面是一个简单的C++类的例子：

class Circle { 
private: 
double radius; // 半径 
 
 
public: 
// 构造函数 
Circle(double r) { 
radius = r; 
} 
 
 
// 计算面积 
double getArea() { 
return 3.14 * radius * radius; 
} 
 
 
// 计算周长 
double getPerimeter() { 
return 2 * 3.14 * radius; 
} 
};

 在上面的例子中，我们定义了一个名为Circle的类。这个类有两个私有成员变量：radius（半径）和pi（圆周率，在类中未被使用）。这个类还有三个公共成员函数：Circle()（构造函数），getArea()（计算圆的面积），getPerimeter()（计算圆的周长）。

我们可以使用这个类来创建一个Circle对象，然后使用对象调用类的方法：

int main() { 
Circle c(5); // 创建一个Circle对象，半径为5 
cout << "Area: " << c.getArea() << endl; // 输出圆的面积 
cout << "Perimeter: " << c.getPerimeter() << endl; // 输出圆的周长 
return 0; 
}

类的成员函数可以在类内部定义，也可以在类外部定义。在类内部定义时，函数必须在类声明中声明为inline。在类外部定义时，函数前面必须加上类名和作用域解析运算符:: 例如：

// 类内部定义函数 
class Circle { 
private: 
double radius; 
public: 
Circle(double r) { radius = r; } 
inline double getArea() { return 3.14 * radius * radius; } 
}; 
 
 
// 类外部定义函数 
inline double Circle::getArea() { 
return 3.14 * radius * radius; 
}

在C++中，对象是类的实例。类是定义对象属性（成员变量）和行为（成员函数）的方式。以下是一个简单的例子：

class Dog { 
private: 
string name; 
int age; 
public: 
Dog(string n, int a) { //构造函数 
name = n; 
age = a; 
} 
 
 
void bark() { //行为 
cout << "Woof!" << endl; 
} 
};

这个类定义了一个“Dog”对象。每个Dog对象都有自己的name和age属性，并且都可以调用bark方法。

创建Dog对象的代码如下：

Dog myDog("Buddy", 3); //创建一个名为Buddy，年龄为3的Dog对象

此时，myDog就是一个具体的对象，它具有Dog类的所有属性和行为。你可以这样访问它的属性：

cout << "Name: " << myDog.name << endl; //输出名字 
cout << "Age: " << myDog.age << endl; //输出年龄

你也可以调用它的行为：

myDog.bark(); //让狗叫

面向过程的结构化程序设计：

程序 = 算法 + 数据结构 

对象 = 算法 + 数据结构

程序 = （对象+对象+对象+...）+消息

消息的作用就是对对象的控制

类代表了某一批控制对象的共性和特征。类是对象的抽象，而对象是类的具体实例。

在C++中，类的定义遵循以下格式：

class ClassName { 
// 成员变量 
type variableName; 
// 成员函数 
void functionName() { 
// 函数体 
} 
};

下面是一个具体示例：

class Person { 
private: 
string name; // 成员变量 
int age; // 成员变量 
 
 
public: 
// 构造函数 
Person(string n, int a) { 
name = n; 
age = a; 
} 
 
 
// getter和setter函数 
void setName(string n) { 
name = n; 
} 
string getName() { 
return name; 
} 
 
 
void setAge(int a) { 
age = a; 
} 
int getAge() { 
return age; 
} 
};

在这个例子中，我们定义了一个Person类，包含两个私有成员变量name和age，以及一些公有成员函数，如构造函数、getter和setter函数等。这些成员函数可以被类的实例调用，用于访问和修改类的成员变量。

 ps:每一个限制词（private等）在类体中可以使用多次。一旦使用了限制词，该限制词一直有效，直到下一个限制词开始为止。

        如果未加说明，类中成员默认的访问权限是private，即私有的。

类与对象，案例1实现：  

#include
using namespace std;
 
class Student
{
public:  //公有成员
	void InputData()
	{
		cout <<"\n\n please input your student number:" ;
		cin  >> snum;
		cout <<"please input your name:";
		cin  >>sname;
		cout <<"please input your sscore";
		cin  >>sscore;
	}	
	void    OutputData(); //函数声明
	double  daverage;    //平均数
	
private: 	//私有成员
	int      snum;	    
	char     sname[10];
	double 	 sscore;	
	
protected:  //保护成员
 
};
	Student stu2; //声明全局对象2
 
//函数实现在外面  inline内联函数
inline void student:: OutputData()
{
		cout << "\n\n The student information is as follows:"	;
		cout << "student number:" << snum   << endl;
		cout << "student name:"   << sname  << endl;
		cout << "student score:"  << sscore << endl;
}
 
void testfunc()  //测试函数封装
{
	stu2.daverage = 100;
	cout << "jack average is : " <<	stu2.daverage << endl <
}
 
int main()
{
	Student stu1;    //函数调用
	stu1.InputData;  //调用输入函数为私有数据成员赋值
	stu1.OutputData; //调用输出函数将数据信息输出
	stu1.daverage = 100; //为什么可以调用daverage  因为这个数据类型是公有的
	//stu1.dscore = 90	 //为什么不可以调用dscore  因为这个数据是私有数据成员  外界不可以访问
	
	testfunc();  //测试函数调用
	
	return 0;	
}