C++类是一种用于面向对象编程的重要概念。类是一种数据类型，它可以包含数据成员和函数成员。数据成员是类中的变量，而函数成员是类中的函数。
C++中的类定义通常放在头文件(.h或.hpp)中，而实现则放在源文件(.cpp)中。以下是一个简单的类的示例，它表示一个具有姓名和年龄属性的人：
//Person.hpp
#ifndefPERSON_HPP
#definePERSON_HPP
#includestring
classPerson{
public:
Person(conststd::stringname,intage);
voidsayHello()const;
private:
std::stringm_name;
intm_age;
};
#endif
//Person.cpp
#include"Person.hpp"
#includeiostream
Person::Person(conststd::stringname,intage):
m_name(name),m_age(age){}
voidPerson::sayHello()const{
std::cout"Hello,mynameis"m_name"andIam"m_age"yearsold."std::endl;
}
在头文件中，我们使用class关键字定义了一个名为Person的类。在这个类中，我们声明了两个成员函数：构造函数和sayHello函数，以及两个数据成员：m_name和m_age。
在构造函数中，我们初始化了数据成员m_name和m_age。在sayHello函数中，我们输出了一个简单的问候语，包含了对象的姓名和年龄。
在实现文件中，我们包含了头文件，并定义了类成员函数。注意到函数sayHello前有一个const修饰符，这是因为该函数并不修改类的任何数据成员。另外，我们使用作用域解析运算符::来实现函数的定义。
接下来是如何使用这个类：
#include"Person.hpp"
intmain(){
Personp("Alice",25);
p.sayHello();
return0;
}
在main函数中，我们创建了一个名为p的Person对象，并向其构造函数传递了姓名和年龄参数。接着，我们调用了p的sayHello函数，它会输出"Hello,mynameisAliceandIam25yearsold."。
这是一个简单的C++类的示例。当你需要创建一个新类型的数据结构，并在其中封装数据和行为时，C++类是一个非常有用的工具。
接下来我介绍C++类的一些更高级的概念和用法。
1.访问控制
在上面的示例中，我们使用了public关键字来声明公共成员函数和数据成员。C++类中还有两种访问控制：private和protected。private成员只能在类内部访问，而protected成员可以在类内部和子类中访问。默认情况下，C++中的类成员是私有的。
以下是一个更详细的示例，展示了如何使用private和protected成员：
//Example.hpp
#ifndefEXAMPLE_HPP
#defineEXAMPLE_HPP
#includeiostream
classExample{
public:
Example(intvalue);
voidsetValue(intvalue);
intgetValue()const;
protected:
voidlogValue()const;
private:
intm_value;
};
//Example.cpp
#include"Example.hpp"
Example::Example(intvalue):
m_value(value){}
voidExample::setValue(intvalue){
m_value=value;
}
intExample::getValue()const{
returnm_value;
}
voidExample::logValue()const{
std::cout"Thevalueis"m_valuestd::endl;
}
//DerivedExample.hpp
#ifndefDERIVED_EXAMPLE_HPP
#defineDERIVED_EXAMPLE_HPP
#include"Example.hpp"
classDerivedExample:publicExample{
public:
DerivedExample(intvalue);
voidlogValue()const;
};
//DerivedExample.cpp
#include"DerivedExample.hpp"
DerivedExample::DerivedExample(intvalue):
Example(value){}
voidDerivedExample::logValue()const{
std::cout"Thederivedvalueis"getValue()std::endl;
}
在Example类中，我们使用了public、protected和private关键字分别声明了三种成员访问控制。在DerivedExample类中，我们使用public继承Example类，并覆盖了其logValue函数。
2.继承
在C++中，一个类可以通过继承另一个类来获取其成员变量和成员函数。继承的语法如下：
classChildClass:publicParentClass{
//...
};
在这个示例中，ChildClass继承了ParentClass中所有的public和protected成员。
以下是一个简单的示例，展示了如何继承和使用父类的成员：
//Parent.hpp
#ifndefPARENT_HPP
#definePARENT_HPP
classParent{
public:
voidsayHello()const;
};
//Parent.cpp
#include"Parent.hpp"
#includeiostream
voidParent::sayHello()const{
std::cout"Hellofromparent!"std::endl;
}
//Child.hpp
#ifndefCHILD_HPP
#defineCHILD_HPP
#include"Parent.hpp"
classChild:publicParent{
public:
voidsayHello()const;
};
//Child.cpp
#include"Child.hpp"
#includeiostream
voidChild::sayHello()const{
std::cout"Hellofromchild!"std::endl;
Parent::sayHello();
}
//main.cpp
#include"Child.hpp"
intmain(){
Childc;
c.sayHello();
return0;
}
在这个示例中，我们定义了一个名为Parent的类，它只有一个成员函数sayHello。然后我们定义了一个名为Child的类，它从Parent类继承，并覆盖了sayHello函数。在Child类的sayHello函数中，我们首先输出"Hellofromchild!"，然后调用Parent类的sayHello函数，从而输出"Hellofromparent!"。
在main函数中，我们创建了一个Child类的对象c，并调用其sayHello函数。由于Child类覆盖了Parent类的sayHello函数，因此在调用c.sayHello时，先输出"Hellofromchild!"，然后输出"Hellofromparent!"。
3.虚函数
在C++中，虚函数允许子类覆盖父类的函数，并通过父类指针或引用调用子类的函数。虚函数的语法如下：
classParent{
public:
virtualvoidfoo();
};
classChild:publicParent{
public:
voidfoo()override;
};
在这个示例中，我们使用virtual关键字声明了一个名为foo的虚函数。在Child类中，我们使用override关键字覆盖了Parent类中的foo函数。
以下是一个简单的示例，展示了如何使用虚函数：
//Animal.hpp
#ifndefANIMAL_HPP
#defineANIMAL_HPP
classAnimal{
public:
virtualvoidspeak()const;
};
//Animal.cpp
#include"Animal.hpp"
#includeiostream
voidAnimal::speak()const{
std::cout"Animalspeaks!"std::endl;
}
//Cat.hpp
#ifndefCAT_HPP
#defineCAT_HPP
#include"Animal.hpp"
classCat:publicAnimal{
public:
voidspeak()constoverride;
};
//Cat.cpp
#include"Cat.hpp"
#includeiostream
voidCat::speak()const{
std::cout"Meow!"std::endl;
}
//main.cpp
#include"Animal.hpp"
#include"Cat.hpp"
intmain(){
Animal*a=newAnimal();
Animal*c=newCat();
a-speak();
c-speak();
deletea;
deletec;
return0;
}
在这个示例中，我们定义了一个名为Animal的类，并声明了一个虚函数speak。然后我们定义了一个名为Cat的类，它从Animal类继承，并覆盖了speak函数。在main函数中，我们分别创建了Animal和Cat类的对象，并通过它们的指针调用speak函数。由于Cat类覆盖了Animal类的speak函数，因此在调用c-speak时，输出"Meow!"而不是"Animalspeaks!"。
4.纯虚函数和抽象类
在C++中，纯虚函数允许我们创建抽象类。抽象类是不能被实例化的类，只能被用作基类。纯虚函数的语法如下：
classAbstract{
public:
virtualvoidfoo()const=0;
};
在这个示例中，我们使用=0语法声明了一个名为foo的纯虚函数。因为Abstract类中包含纯虚函数，所以它是一个抽象类，不能被实例化。
以下是一个简单的示例，展示了如何使用抽象类：
//Shape.hpp
#ifndefSHAPE_HPP
#defineSHAPE_HPP
classShape{
public:
virtualdoublearea()const=0;
virtualdoubleperimeter()const=0;
};
//Circle.hpp
#ifndefCIRCLE_HPP
#defineCIRCLE_HPP
#include"Shape.hpp"
classCircle:publicShape{
public:
Circle(doubleradius);
doublearea()constoverride;
doubleperimeter()constoverride;
private:
doublem_radius;
};
//Circle.cpp
#include"Circle.hpp"
#includecmath
Circle::Circle(doubleradius):m_radius(radius){}
doubleCircle::area()const{
returnM_PI*m_radius*m_radius;
}
doubleCircle::perimeter()const{
return2*M_PI*m_radius;
}
//Rectangle.hpp
#ifndefRECTANGLE_HPP
#defineRECTANGLE_HPP
#include"Shape.hpp"
classRectangle:publicShape{
public:
Rectangle(doublewidth,doubleheight);
doublearea()constoverride;
doubleperimeter()constoverride;
private:
doublem_width;
doublem_height;
};
//Rectangle.cpp
#include"Rectangle.hpp"
Rectangle::Rectangle(doublewidth,doubleheight):m_width(width),m_height(height){}
doubleRectangle::area()const{
returnm_width*m_height;
}
doubleRectangle::perimeter()const{
return2*(m_width+m_height);
}
//main.cpp
#include"Shape.hpp"
#include"Circle.hpp"
#include"Rectangle.hpp"
#includeiostream
voidprintShapeInfo(constShapeshape){
std::cout"Area:"shape.area()std::endl;
std::cout"Perimeter:"shape.perimeter()std::endl;
}
intmain(){
Shape*shapes[2];
shapes[0]=newCircle(5);
shapes[1]=newRectangle(4,6);
for(inti=0;i2;++i){
printShapeInfo(*shapes);
deleteshapes;
}
return0;
}
在这个示例中，我们定义了一个名为Shape的抽象类，并声明了两个纯虚函数area和perimeter。然后我们定义了一个名为Circle的类，它从Shape类继承，并实现了area和perimeter函数。同样，我们定义了一个名为Rectangle的类，它也从Shape类继承，并实现了area和perimeter函数。在main函数中，我们创建了一个Shape指针数组，并使用它们的指针调用area和perimeter函数。由于Circle和Rectangle类都实现了Shape类的纯虚函数，因此它们不再是抽象类，可以被实例化。
总结
这篇教程介绍了C++类的一些基本概念和语法，包括类的定义、成员函数、继承、虚函数、纯虚函数和抽象类。这些概念和语法是C++编程中非常重要的基础，掌握它们可以帮助我们更好地设计和实现类和对象。