c++类基础知识

引入

下面是一个从菜鸟抄来的例子，可以看到BOX定义了两个公共函数，get和set，在类里面声明，在外面定义，也可以直接在里面定义。

#include <iostream>
 
using namespace std;
 
class Box
{
   public:
      double length;   // 长度
      double breadth;  // 宽度
      double height;   // 高度
      // 成员函数声明
      double get(void);
      void set( double len, double bre, double hei );
};
// 成员函数定义
double Box::get(void)
{
    return length * breadth * height;
}
 
void Box::set( double len, double bre, double hei)
{
    length = len;
    breadth = bre;
    height = hei;
}
int main( )
{
   Box Box1;        // 声明 Box1，类型为 Box
   Box Box2;        // 声明 Box2，类型为 Box
   Box Box3;        // 声明 Box3，类型为 Box
   double volume = 0.0;     // 用于存储体积
 
   // box 1 详述
   Box1.height = 5.0; 
   Box1.length = 6.0; 
   Box1.breadth = 7.0;
 
   // box 2 详述
   Box2.height = 10.0;
   Box2.length = 12.0;
   Box2.breadth = 13.0;
 
   // box 1 的体积
   volume = Box1.height * Box1.length * Box1.breadth;
   cout << "Box1 的体积：" << volume <<endl;
 
   // box 2 的体积
   volume = Box2.height * Box2.length * Box2.breadth;
   cout << "Box2 的体积：" << volume <<endl;
 
 
   // box 3 详述
   Box3.set(16.0, 8.0, 12.0); 
   volume = Box3.get(); 
   cout << "Box3 的体积：" << volume <<endl;
   return 0;
}

继承

成员类型

与其它语言类似，都有protected、private以及public

private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；

protected 成员可以被派生类访问。

class b{
protected:
	int bvalue = 5;
};
class a::b{
public:
	void fun(){
		cout<<bvalue<<endl;//能访问父类的protected, 不能是private
	}
};

protected能被继承的类在成员函数中访问，但不能被实例化的变量调用。

无论是声明还是继承，默认就是private

class a{
	int x;//默认private
};

父子变量名冲突

假如子类中变量与父类变量名冲突了。

class B{
public: 
	int age = 100;
};
class A::public B{
public:
	int age = 10;	
};

int main(void){
	A a;
	cout<<a.age;//10。
	cout<<a.B::age;//命名空间来获取父类 100
}

继承类型

1. 公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
2. 保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
3. 私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

构造和析构

构造和析构都是没有返回值的，可以允许重载。

初始化列表：用于在构造函数中快速初始化成员变量。

下面代码就直接将构造函数传过来的a赋值给X,b给Y，c给Z

C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}

拷贝构造函数：能直接拷贝一个对象构造一个新的对象

是构造函数的一种，属于构造函数的重载。

C::C(const ClassName& other);

C c1;
C c2 = C(c1);//能将c1的所有值复制给c2，且c2和c1后续没有什么引用关系。

能用于函数传形参，形参为对象的时候

析构函数：它会在每次删除所创建的实例对象时执行，用于最后释放资源。
与构造函数类似，就是在前面多了个波浪~

C{
public:
	C()
	~C();
};

友元变量

友元变量和友元类都不是成员函数和变量，但是可以访问其中的private和protected，只需要在类定义中多一个定义友元的firend关键字。

class Box
{
    double width;
public:
    friend void printWidth(Box box);
    friend class BigBox;
    void setWidth(double wid);
};

class BigBox
{
public :
    void Print(int width, Box &box)
    {
        // BigBox是Box的友元类，它可以直接访问Box类的任何成员
        box.setWidth(width);
        cout << "Width of box : " << box.width << endl;
    }
};

// 成员函数定义
void Box::setWidth(double wid)
{
    width = wid;
}

// 请注意：printWidth() 不是任何类的成员函数
void printWidth(Box box)
{
    /* 因为 printWidth() 是 Box 的友元，它可以直接访问该类的任何成员 */
    cout << "Width of box : " << box.width << endl;
}

静态成员函数

静态成员函数和静态成员变量都只是在普通的变量上加一个static，效果是可以直接通过类名访问，不属于实例化对象的东西，属于类。

class MyClass {
public:
    static void staticFunction() {
    }
};

同时，假如是内部的函数，可以直接调用，不用加类名。

派生类的函数也可以直接调用，不用加命名空间。

多态

多态就类似java的抽象类， 基类用virtual关键字定义一个纯虚函数，而子类就必须用override关键字重写纯虚函数。

class Shape {
public:
    virtual void draw() {
        std::cout << "绘制形状" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() override {
        std::cout << "绘制矩形" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "绘制圆形" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Rectangle();
    Shape* shape2 = new Circle();

    shape1->draw();  // 调用Rectangle的draw函数
    shape2->draw();  // 调用Circle的draw函数

    delete shape1;
    delete shape2;

    return 0;
}