C++NUM5

类&对象&＃xff1a;

类用于指定对象的形式&＃xff0c;它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
类定义是以关键字 class 开头&＃xff0c;后跟类的名称。类的主体是包含在一对花括号中。类定义后必须跟着一个分号或一个声明列表。
例如&＃xff1a;
class Box{
    public:
        double length;
        double breadth;
        double height;
}; 

在类对象作用域内&＃xff0c;公共成员在类的外部是可访问的

对象&＃xff1a;
类Box的2个对象
Box box1&＃xff1b;  // 声明 Box1&＃xff0c;类型为 Box
Box box2&＃xff1b;  // 声明 Box2&＃xff0c;类型为 Box
对象 Box1 和 Box2 都有它们各自的数据成员

类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问。

例如&＃xff1a;
#include
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 &＃61; len;
    breadth &＃61; bre;
    height &＃61; hei;
}
int main( )
{
   Box Box1;        // 声明 Box1&＃xff0c;类型为 Box
   Box Box2;        // 声明 Box2&＃xff0c;类型为 Box
   Box Box3;        // 声明 Box3&＃xff0c;类型为 Box
   double volume &＃61; 0.0;     // 用于存储体积
   // box 1 详述
   Box1.height &＃61; 5.0; 
   Box1.length &＃61; 6.0; 
   Box1.breadth &＃61; 7.0;
   // box 2 详述
   Box2.height &＃61; 10.0;
   Box2.length &＃61; 12.0;
   Box2.breadth &＃61; 13.0;
   // box 1 的体积
   volume &＃61; Box1.height * Box1.length * Box1.breadth;
   cout <<"Box1 的体积&＃xff1a;" <    // box 2 的体积
   volume &＃61; Box2.height * Box2.length * Box2.breadth;
   cout <<"Box2 的体积&＃xff1a;" <    // box 3 详述
   Box3.set(16.0, 8.0, 12.0); 
   volume &＃61; Box3.get(); 
   cout <<"Box3 的体积&＃xff1a;" <    return 0;
}

双冒号&＃xff1a;&＃xff1a;       https://blog.csdn.net/tham_/article/details/44905561?utm_medium&＃61;distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0.no_search_link&spm&＃61;1001.2101.3001.4242.0
1.声明一个类A。声明一个成员函数void f&＃xff08;&＃xff09;&＃xff0c;但没有在类的声明里给出f的定义&＃xff0c;那么在类外定义F时&＃xff0c;写成voidA::f(),表示这个f&＃xff08;&＃xff09;函数是类A的成员函数
 

类成员函数&＃xff1a;那些把定义和原型写在类定义内部的函数
成员函数可以定义在类定义内部&＃xff0c;或者单独使用范围解析运算符 :: 来定义。
1.在类定义中定义的成员函数把函数声明为内联的
class Box
{
   public:
      double length;      // 长度
      double breadth;     // 宽度
      double height;      // 高度
   
      double getVolume(void)
      {
         return length * breadth * height;
      }
};
2.在类的外部使用范围解析运算符 :: 定义该函数
double Box::getVolume(void)
{
    return length * breadth * height;
}
在 :: 运算符之前必须使用类名。调用成员函数是在对象上使用点运算符&＃xff08;.&＃xff09;
Box myBox;
myBox.getVolume();

类访问修饰符&＃xff1a; 
数据封装&＃xff0c;防止函数直接访问类类型的内部成员
类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 来指定的。关键字 public、private、protected 称为访问修饰符。

公有成员在程序中的类的外部是可访问的
私有成员变量或函数在类的外部是不可访问的&＃xff0c;只有类和友元函数可以访问私有成员
 实际操作中&＃xff0c;我们一般会在私有区域定义数据&＃xff0c;在公有区域定义相关的函数&＃xff0c;以便在类的外部也可以调用这些函数
 例如&＃xff1a;
#include
using namespace std;
class Box
{
   public:
      double length;
      void setWidth( double wid );
      double getWidth( void );
   private:
      double width;
};
 
// 成员函数定义
double Box::getWidth(void)
{
    return width ;
}
void Box::setWidth( double wid )
{
    width &＃61; wid;
}
// 程序的主函数
int main( )
{
   Box box;
   // 不使用成员函数设置长度
   box.length &＃61; 10.0; // OK: 因为 length 是公有的
   cout <<"Length of box : " <    // 不使用成员函数设置宽度
   // box.width &＃61; 10.0; // Error: 因为 width 是私有的
   box.setWidth(10.0);  // 使用成员函数设置宽度
   cout <<"Width of box : " <    return 0;
}

protected受保护与私有十分相似
例如&＃xff1a;
#include
using namespace std;
 
class Box
{
   protected:
      double width;
};
class SmallBox:Box // SmallBox 是派生类
{
   public:
      void setSmallWidth( double wid );
      double getSmallWidth( void );
}; 
// 子类的成员函数
double SmallBox::getSmallWidth(void)
{
    return width ;
}
 
void SmallBox::setSmallWidth( double wid )
{
    width &＃61; wid;
}
 
// 程序的主函数
int main( )
{
   SmallBox box;
 
   // 使用成员函数设置宽度
   box.setSmallWidth(5.0);
   cout <<"Width of box : "<    return 0;
}

注意注意&＃xff1a;
有public, protected, private三种继承方式&＃xff0c;它们相应地改变了基类成员的访问属性。
1.public 继承&＃xff1a;基类 public 成员&＃xff0c;protected 成员&＃xff0c;private 成员的访问属性在派生类中分别变成&＃xff1a;public, protected, private
2.protected 继承&＃xff1a;基类 public 成员&＃xff0c;protected 成员&＃xff0c;private 成员的访问属性在派生类中分别变成&＃xff1a;protected, protected, private
3.private 继承&＃xff1a;基类 public 成员&＃xff0c;protected 成员&＃xff0c;private 成员的访问属性在派生类中分别变成&＃xff1a;private, private, private
但无论哪种继承方式&＃xff0c;上面两点都没有改变&＃xff1a;
1.private 成员只能被本类成员&＃xff08;类内&＃xff09;和友元访问&＃xff0c;不能被派生类访问&＃xff1b;
2.protected 成员可以被派生类访问。

如果继承时不显示声明是private,protected,public,则默认是private继承&＃xff0c;在struct中默认是public继承
 例子&＃xff1a; 
https://www.runoob.com/cplusplus/cpp-class-access-modifiers.html

基类的protected成员&＃xff0c;在派生类中仍是protected可以被派生类访问。

类构造函数&析构函数&＃xff1a;
构造函数的名称与类的名称是完全相同&＃xff0c;并且不会返回任何类型&＃xff0c;也不会返回 void。
例子&＃xff1a;
#include
using namespace std;
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();  // 这是构造函数  Line(double len); 这是带参数的构造函数 
 
   private:
      double length;
};
// 成员函数定义&＃xff0c;包括构造函数
Line::Line(void)   //Line&＃xff1a;&＃xff1a;Line(double len) 
{
    cout <<"Object is being created" < }
void Line::setLength( double len )
{
    length &＃61; len;
}
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
   // 设置长度
   line.setLength(6.0); 
   cout <<"Length of line : " <    return 0;
}

使用初始化列表来初始化字段&＃xff1a;
Line::Line( double len): length(len)
{
    cout <<"Object is being created, length &＃61; " < }
等同于&＃xff1a;
Line::Line( double len)
{
    length &＃61; len;
    cout <<"Object is being created, length &＃61; " < }
假设有一个类 C&＃xff0c;具有多个字段 X、Y、Z 等需要进行初始化&＃xff0c;同理地&＃xff0c;您可以使用上面的语法&＃xff0c;只需要在不同的字段使用逗号进行分隔&＃xff0c;如下所示&＃xff1a;
C::C( double a, double b, double c): X(a), Y(b), Z(c)
{
  ....
}

类的析构函数&＃xff1a;它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的&＃xff0c;只是在前面加了个波浪号&＃xff08;~&＃xff09;作为前缀&＃xff0c;它不会返回任何值&＃xff0c;也不能带有任何参数。析构函数有助于在跳出程序&＃xff08;比如关闭文件、释放内存等&＃xff09;前释放资源。
例如&＃xff1a;
class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明
 
   private:
      double length;
};
// 成员函数定义&＃xff0c;包括构造函数
Line::Line(void)
{
    cout <<"Object is being created" < }
Line::~Line(void)
{
    cout <<"Object is being deleted" < }
void Line::setLength( double len )
{
    length &＃61; len;
}
double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;
   // 设置长度
   line.setLength(6.0); 
   cout <<"Length of line : " <    return 0;
}

拷贝构造函数:它在创建对象时&＃xff0c;是使用同一类中之前创建的对象来初始化新创建的对象。
通过使用另一个同类型的对象来初始化新创建的对象。
复制对象把它作为参数传递给函数。
复制对象&＃xff0c;并从函数返回这个对象。
classname(const classname &obj){ //obj是一个对象引用&＃xff0c;该对象是用于初始化另一个对象 
    //构造函数的主体 
}

例如&＃xff1a;
#include
using namespace std;
class line{
    public:
        int getlength(void);
        line(int len);//简单的构造函数
        line(const line &obj);//拷贝构造函数
        ~line();//析构函数
    private:
        int *ptr; 
};

//成员函数定义&＃xff0c;包括构造函数
line::line(int len){
    cout<<"调用构造函数"<     //为指针分配内存
    ptr&＃61;new int;
    *ptr&＃61;len; 
} 
line::line(const line &obj){
    cout<<"调用拷贝构造函数并未指针ptr分配内存"<     ptr&＃61;new int;   //new https://blog.csdn.net/xiaorenwuzyh/article/details/44514815
    *ptr&＃61;*obj.ptr;//拷贝值
}
line::~line(void)
{
    cout<<"释放内存"<     delete ptr;
}
int line::getlength(void){
    return *ptr;
}
void display(line obj){
    cout<<"line大小&＃xff1a;"< }

int main(){
    line line1(10);
    line line2&＃61;line1;//调用拷贝构造函数 
    display(line1);
    display(line2);
    return 0;
}

友元函数&＃xff1a; https://www.runoob.com/cplusplus/cpp-friend-functions.html
定义在类的外部&＃xff0c;但有权访问所有私有&＃xff08;private&＃xff09;和保护&＃xff08;protected&＃xff09;成员&＃xff0c;友元函数不是成员函数
 友元可以是一个函数&＃xff0c;该函数被称为友元函数&＃xff1b;友元也可以是一个类&＃xff0c;该类被称为友元类&＃xff0c;在这种情况下&＃xff0c;整个类及其所有成员都是友元。
 需要在类定义中该函数原型前使用关键字friend
 class box{
     double width;
     public:
         double length;
         friend void printwidth(box box);
         void setwidth(double wid);
 }; 
声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元&＃xff0c;需要在类 ClassOne 的定义中放置如下声明&＃xff1a;
friend class ClassTwo;
例如&＃xff1a;
#include
using namespace std;
class Box
{
   double width;
public:
   friend void printWidth( Box box );
   void setWidth( double wid );
};
// 成员函数定义
void Box::setWidth( double wid )
{
    width &＃61; wid;
}
// 请注意&＃xff1a;printWidth() 不是任何类的成员函数
void printWidth( Box box )
{
   /* 因为 printWidth() 是 Box 的友元&＃xff0c;它可以直接访问该类的任何成员 */
   cout <<"Width of box : " < }
// 程序的主函数
int main( )
{
   Box box;
   // 使用成员函数设置宽度
   box.setWidth(10.0);
   // 使用友元函数输出宽度
   printWidth( box );
   return 0;
}

内联函数&＃xff1a;如果想把一个函数定义为内联函数&＃xff0c;则需要在函数名前面放置关键字 inline&＃xff0c;在调用函数之前需要对函数进行定义。
在类定义中的定义的函数都是内联函数&＃xff0c;即使没有使用 inline 说明符。
1.在内联函数内不允许使用循环语句和开关语句&＃xff1b;
2.内联函数的定义必须出现在内联函数第一次调用之前&＃xff1b;
3.类结构中所在的类说明内部定义的函数是内联函数。 
如&＃xff1a;
inline int Max(int x, int y)
{
   return (x > y)? x : y;
}
// 程序的主函数
int main( )
{
   cout <<"Max (20,10): " <    cout <<"Max (0,200): " <    cout <<"Max (100,1010): " <    return 0;
}
 
 
this指针&＃xff1a;
每一个对象都能通过 this 指针来访问自己的地址。this 指针是所有成员函数的隐含参数。因此&＃xff0c;在成员函数内部&＃xff0c;它可以用来指向调用对象。
友元函数没有this指针&＃xff0c;只有成员函数才有this指针
this只能用在类的内部&＃xff0c;通过this可以访问类的所有成员&＃xff0c;包括private&＃xff0c;protected&＃xff0c;public属性
this 是一个指针&＃xff0c;要用->来访问成员变量或成员函数。
以成员函数setname(char *name)为例&＃xff0c;它的形参是name&＃xff0c;和成员变量name重名&＃xff0c;如果写作name &＃61; name;这样的语句&＃xff0c;就是给形参name赋值&＃xff0c;而不是给成员变量name赋值。而写作this -> name &＃61; name;后&＃xff0c;&＃61;左边的name就是成员变量&＃xff0c;右边的name就是形参&＃xff0c;一目了然。

指向类的指针&＃xff1a;访问指向类的指针的成员&＃xff0c;需要使用成员访问运算符 ->
如&＃xff1a;
class Box
{
   public:
      // 构造函数定义
      Box(double l&＃61;2.0, double b&＃61;2.0, double h&＃61;2.0)
      {
         cout <<"Constructor called." <          length &＃61; l;
         breadth &＃61; b;
         height &＃61; h;
      }
      double Volume()
      {
         return length * breadth * height;
      }
   private:
      double length;     // Length of a box
      double breadth;    // Breadth of a box
      double height;     // Height of a box
};
int main(void)
{
   Box Box1(3.3, 1.2, 1.5);    // Declare box1
   Box Box2(8.5, 6.0, 2.0);    // Declare box2
   Box *ptrBox;                // Declare pointer to a class.
   // 保存第一个对象的地址
   ptrBox &＃61; &Box1;
   // 现在尝试使用成员访问运算符来访问成员
   cout <<"Volume of Box1: " <Volume() <    // 保存第二个对象的地址
   ptrBox &＃61; &Box2;
   // 现在尝试使用成员访问运算符来访问成员
   cout <<"Volume of Box2: " <Volume() <    return 0;
}

静态成员&＃xff1a;
使用static关键字把类成员定义为静态
class runoob{
    public:
        static int age; //静态变量
        int users;//实例变量
    public:
    func{
    int local;//局部变量
    } 
};
静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句&＃xff0c;在创建第一个对象时&＃xff0c;所有的静态数据都会被初始化为零。我们不能把静态成员的初始化放置在类的定义中&＃xff0c;但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化。

静态成员函数&＃xff1a;
静态函数只要使用类名加范围解析运算符 :: 就可以访问
静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。
静态成员函数有一个类范围&＃xff0c;他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。
静态成员函数与普通成员函数的区别&＃xff1a;
静态成员函数没有 this 指针&＃xff0c;只能访问静态成员&＃xff08;包括静态成员变量和静态成员函数&＃xff09;。
普通成员函数有 this 指针&＃xff0c;可以访问类中的任意成员&＃xff1b;而静态成员函数没有 this 指针。

继承&＃xff1a;
已有的类称为基类&＃xff0c;新建的类称为派生类
例如&＃xff1a;
// 基类
class Animal {
    // eat() 函数
    // sleep() 函数
};
//派生类
class Dog : public Animal {
    // bark() 函数
};
类派生列表以一个或多个基类命名&＃xff0c;形式如下&＃xff1a;
class derived-class:access-specifier base-class
其中access-specifier是public&＃xff0c;protected&＃xff0c;private&＃xff1b;base-class是之前定义过的某个类的名称
如果未使用访问修饰符access-specifier&＃xff0c;则默认为private
如&＃xff1a;
class Shape 
{
   public:
      void setWidth(int w)
      {
         width &＃61; w;
      }
      void setHeight(int h)
      {
         height &＃61; h;
      }
   protected:
      int width;
      int height;
};
// 派生类
class Rectangle: public Shape
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
int main(void)
{
   Rectangle Rect;
   Rect.setWidth(5);
   Rect.setHeight(7);
   // 输出对象的面积
   cout <<"Total area: " <    return 0;
} 

公有继承&＃xff08;public&＃xff09;&＃xff1a;当一个类派生自公有基类时&＃xff0c;基类的公有成员也是派生类的公有成员&＃xff0c;基类的保护成员也是派生类的保护成员&＃xff0c;基类的私有成员不能直接被派生类访问&＃xff0c;但是可以通过调用基类的公有和保护成员来访问。
保护继承&＃xff08;protected&＃xff09;&＃xff1a; 当一个类派生自保护基类时&＃xff0c;基类的公有和保护成员将成为派生类的保护成员。
私有继承&＃xff08;private&＃xff09;&＃xff1a;当一个类派生自私有基类时&＃xff0c;基类的公有和保护成员将成为派生类的私有成员。

多继承&＃xff1a;
一个子类可以有多个父类&＃xff0c;它继承多个父亲的特性
语法&＃xff1a;
class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};
例如&＃xff1a;
// 基类 Shape
class Shape 
{
   public:
      void setWidth(int w)
      {
         width &＃61; w;
      }
      void setHeight(int h)
      {
         height &＃61; h;
      }
   protected:
      int width;
      int height;
};
// 基类 PaintCost
class PaintCost 
{
   public:
      int getCost(int area)
      {
         return area * 70;
      }
};
// 派生类
class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
int main(void)
{
   Rectangle Rect;
   int area;
   Rect.setWidth(5);
   Rect.setHeight(7);
   area &＃61; Rect.getArea();  
   // 输出对象的面积
   cout <<"Total area: " <    // 输出总花费
   cout <<"Total paint cost: $" <    return 0;
}

虚继承&＃xff1a;
class类名&＃xff1a;virtual继承方式  父类名
class D{......};
class B: virtual public D{......};
class A: virtual public D{......};
class C: public B, public A{.....};

重载运算符和重载函数
C&＃43;&＃43; 允许在同一作用域中的某个函数和运算符指定多个定义&＃xff0c;分别称为函数重载和运算符重载。
选择最合适的重载函数或重载运算符的过程&＃xff0c;称为重载决策。
在同一个作用域内&＃xff0c;可以声明几个功能类似的同名函数&＃xff0c;但是这些同名函数的形式参数&＃xff08;指参数的个数、类型或者顺序&＃xff09;必须不同。
函数重载&＃xff1a; 
在同一个作用域内&＃xff0c;可以声明几个功能类似的同名函数&＃xff0c;但是这些同名函数的形式参数&＃xff08;指参数的个数、类型或者顺序&＃xff09;必须不同。您不能仅通过返回类型的不同来重载函数。
例如&＃xff1a;
#include
using namespace std;
class printData
{
   public:
      void print(int i) {
        cout <<"整数为: " <       }
      void print(double  f) {
        cout <<"浮点数为: " <       }
      void print(char c[]) {
        cout <<"字符串为: " <       }
};
int main(void)
{
   printData pd;
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] &＃61; "Hello C&＃43;&＃43;";
   pd.print(c);
   return 0;
}