C++ 基础&中级

#include <iostream>
#include <limits>
#include <iomanip>
#include <cstring>
#include <ctime>
#include<fstream>
#include<assert.h>


#if 0
//< iostream > 该文件定义了 cin、cout、cerr 和 clog 对象，分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。

//<iomanip>该文件通过所谓的参数化的流操纵器（比如 setw 和 setprecision），来声明对执行标准化 I / O 有用的服务。

//<fstream>该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

#endif
//-----------------------------------------------------------------------------------//
using namespace std; //告诉编译器使用 std 命名空间。命名空间是 C++ 中一个相对新的概念。
                     //所谓命名空间，实际上就是一个程序设计者命名的内存空间，设计者可以
                     //根据需要指定一些有名字的空间域，把一些全局实体分别放在各个命名空
                     //间中，从而与其他全局实体分隔开来。
//-----------------------------------------------------------------------------------//


#if 0
    //code
    typedef type newname;    //  typedef 为一个已有的类型取一个新的名字
    typedef int feet;        //  告诉编译器，feet 是 int 的另一个名称
    feet distance;           //  下面的声明是完全合法的，它创建了一个整型变量 distance
#endif

//----------------------------------------------------------------------------------//
//define identifier value
#define     LENGTH      (10)
#define     WIDTH       (5)
#define     NEWLINE     ('\n')


// const type variable = value;  //const 类型的对象在程序执行期间不能被修改改变。
// 修饰符 volatile 告诉编译器不需要优化volatile声明的变量，让程序可以直接从内存中
// 读取变量。对于一般的变量编译器会对变量进行优化，将内存中的变量值放在寄存器中以
// 加快读写效率。 由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。
// 只有 C99 增加了新的类型限定符 restrict。


//-----------------------------------------------------------------------------------//
//extern    int    color_name;  // 使用 extern 关键字在任何地方声明一个变量
enum color { red, green, blue } color_name;  // 枚举


static int ZXC_count = 10; /* 全局变量 */



static  unsigned long  sec_seconds;


static  int    rt_balance[5] = { 1000, 2, 3, 17, 50 };  // 带有 5 个元素的整型数组
static  double rt_avg;


// 声明一个结构体类型 Books 
static  struct  Books
{
    char  title[50];
    char  author[50];
    char  subject[100];
    int   book_id;
}_matcher;

//-----------------------------------------------------------------------------------//



//--------------------------------------senior---------------------------------------//

















void    display_fstream_data()
{
    /*
    //-----------------------------------------------------------------------------//
    // ofstream :该数据类型表示输出文件流，用于创建文件并向文件写入信息。
    // ifstream: 该数据类型表示输入文件流，用于从文件读取信息。
    // fstream : 该数据类型通常表示文件流，且同时具有 ofstream 和 ifstream 两种功能，
    //            这意味着它可以创建文件，向文件写入信息，从文件读取信息。
    // 要在 C++ 中进行文件处理，必须在 C++ 源代码文件中包含头文件 <iostream> 和 <fstream>。
    //
    // void open(const char *filename, ios::openmode mode);
    // open() 成员函数的第一参数指定要打开的文件的名称和位置，第二个参数定义文件被打开的模式。
    // ios::app      追加模式。所有写入都追加到文件末尾。
    // ios::ate      文件打开后定位到文件末尾。
    // ios::in       打开文件用于读取。
    // ios::out      打开文件用于写入。
    // ios::trunc    如果该文件已经存在，其内容将在打开文件之前被截断，即把文件长度设为 0。
    //
    // void close();
    //
    //使用流插入运算符（ << ）向文件写入信息---写入文件
    //
    //使用流提取运算符（ >> ）从文件读取信息---读取文件


    //-----------------------------------------------------------------------------//
    */
    
    char data_file[100];

    // 以写模式打开文件
    ofstream    outfile1;
    //outfile.open("afile.dat");
    cout << "*---------------开始--------------*" << "\n" << endl;
    outfile1.open("afile.txt");
    cout << "1---Writing to the file" << "\n" << endl;
    cout << "\t 2---  " << "Enter your name: ";
    cin.getline(data_file, 100);

    // 向文件写入用户输入的数据
    outfile1 <<  data_file << endl;
    cout     << "\t 4---  " << "Enter your age : ";
    cin >> data_file;
    cin.ignore();

    // 再次向文件写入用户输入的数据
    outfile1 << data_file << endl;

    // 关闭打开的文件
    outfile1.close();

    // 以读模式打开文件
    ifstream infile2;
    infile2.open("afile.txt");

    cout << "6---" << "Reading from the file" << endl;
    infile2 >> data_file;

    // 在屏幕上写入数据
    cout << "\t 7---  " << data_file << endl;

    // 再次从文件读取数据，并显示它
    infile2 >> data_file;
    cout << "\t 8---  " << data_file << endl;

    // 关闭打开的文件
    infile2.close();

}


//--------------------------------------中级---------------------------------------//

class Shape_polymorphic
{
    protected:
        int width_polymorphic, height_polymorphic;
    public:
        Shape_polymorphic(int a_polymorphic = 0, int b_polymorphic = 0)
        {
            width_polymorphic = a_polymorphic;
            height_polymorphic = b_polymorphic;
            cout << "* 1---Shape_polymorphic* " << endl;
            cout << width_polymorphic<< height_polymorphic << " \n" << endl;
        }
        virtual int area_polymorphic()
        {
            cout << "2---Parent class area :" << endl;
            return 0;
        }
};
class Rectangle_polymorphic : public Shape_polymorphic
{
    public:
        Rectangle_polymorphic(int a_polymorphic = 0, int b_polymorphic = 0) :Shape_polymorphic(a_polymorphic, b_polymorphic) { }
        int area_polymorphic()
        {
            cout << "Rectangle class area :" << endl;
            return (width_polymorphic * height_polymorphic);
        }
};
class Triangle_polymorphic : public Shape_polymorphic 
{
    public:
        Triangle_polymorphic(int a_polymorphic = 0, int b_polymorphic = 0) :Shape_polymorphic(a_polymorphic, b_polymorphic) { }
        int area_polymorphic()
        {
            cout << "Triangle class area :" << endl;
            return (width_polymorphic * height_polymorphic / 2);
        }
};



void display_polymorphic()
{
    // 多态按字面的意思就是多种形态。当类之间存在层次结构，并且类之间是通过继承关联时，
    // 就会用到多态。C++ 多态意味着调用成员函数时，会根据调用函数的对象的类型来执行不同的函数。
    cout << "* -------------开始------------ * " << " \n" << endl;
    Shape_polymorphic       *shape_polymorphic;
    cout << "* -------shape_polymorphic----- * " << " \n" << endl;
    Rectangle_polymorphic   rec(10, 7);
    cout << "* -------rec----- * " << " \n" << endl;
    Triangle_polymorphic    tri(10, 5);
    cout << "* -------tri----- * " << " \n" << endl;

    // 存储矩形的地址
    shape_polymorphic = &rec;
    cout << "* ----存储矩形的地址---------- * " << " \n" << endl;
    // 调用矩形的求面积函数 area
    shape_polymorphic->area_polymorphic();
    cout << "* ----调用矩形的求面积函数---- * " << " \n" << endl;

    // 存储三角形的地址
    shape_polymorphic = &tri;
    cout << "* -------存储三角形的地址----------- * " << " \n" << endl;
    // 调用三角形的求面积函数 area
    shape_polymorphic->area_polymorphic();
    cout << "* -------调用三角形的求面积函数----- * " << " \n" << endl;

}

class printData_heavy_load
{
    public:
        void print(int i) 
        {
            cout << "整数为: " << i << endl;
        }
        void print(double  f) 
        {
            cout << "浮点数为: " << f << endl;
        }
        void print(char c[]) 
        {
            cout << "字符串为: " << c << endl;
        }
};


void display_heavy_load()
{
// C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。
// 重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，
// 但是它们的参数列表和定义（实现）不相同。当您调用一个重载函数或重载运算符时，
// 编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。
// 选择最合适的重载函数或重载运算符的过程，称为重载决策。

// 在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数
//（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。
// 下面的实例中，同名函数 print() 被用于输出不同的数据类型：

    printData_heavy_load     pd1;

    // 输出整数
    pd1.print(5);
    // 输出浮点数
    pd1.print(500.263);
    // 输出字符串
    char c[] = "Hello C++";
    pd1.print(c);
}


class Shape_inherit
{
        // 基类
    public:
        void setWidth_inherit(int w_inherit)
        {
            width_inherit = w_inherit;
            cout << "1--width_inherit: \t" << width_inherit << "\n"<< endl;
        }
        void setHeight_inherit(int h_inherit)
        {
            height_inherit = h_inherit;
            cout << "2--height_inherit: \t" << height_inherit << "\n" << endl;
        }
    protected:
        int width_inherit;
        int height_inherit;
};

class PaintCost_inherit
{
    // 基类 PaintCost
    public:
        int getCost_inherit(int area_inherit)
        {
            return area_inherit * 70;
        }
};

class Rectangle_inherit : public Shape_inherit
{
    // 派生类
    public:
        int getArea_inherit()
        {
            cout << "3--getArea_inherit: \t" << width_inherit * height_inherit << "\n" << endl;
            return (width_inherit * height_inherit);
        }
};

class Rectangle_inherit2 : public Shape_inherit, public PaintCost_inherit
{
    // 派生类
    public:
        int getArea_inherit()
        {
            return (width_inherit * height_inherit);
        }
};

void display_inherit()
{
// 一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。
// 定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名
// ，
// class derived-class: access-specifier base-class

    Rectangle_inherit Rect1;

    Rect1.setWidth_inherit(15);
    Rect1.setHeight_inherit(17);

    // 输出对象的面积
    cout << "Total area: \t" << Rect1.getArea_inherit() << endl;

//继承类型
// 当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。
// 继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
// 我们几乎不使用 protected 或 private 继承，通常使用 public 继承。
// 当使用不同类型的继承时，遵循以下几个规则：public/protected/private
// 公有继承：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护
//           成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
// 保护继承： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
// 私有继承：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。

    //多继承即一个子类可以有多个父类，它继承了多个父类的特性。
    //class <派生类名> :<继承方式1><基类名1>, <继承方式2><基类名2>, …
    //{
    //    <派生类类体>
    //};

    Rectangle_inherit2       Rect2;
    int area2;

    Rect2.setWidth_inherit(5);
    Rect2.setHeight_inherit(7);

    area2 = Rect2.getArea_inherit();

    // 输出对象的面积
    cout << "Total area: " << Rect2.getArea_inherit() << endl;

    // 输出总花费
    cout << "Total paint cost: $" << Rect2.getCost_inherit(area2) << endl;
}

class class_Line_CC_B
{
    public:
        int     getLength_Line_CC_B(void);
        class_Line_CC_B(int len);                            // 简单的构造函数
        class_Line_CC_B(const class_Line_CC_B &obj_cc);      // 拷贝构造函数
        ~class_Line_CC_B();                                  // 析构函数

    private:
        int *ptr_Line_CC_B;
};

class_Line_CC_B::class_Line_CC_B(int len_CC_B)
{
    // 成员函数定义，包括构造函数
    cout << "1--调用构造函数" << "\t\n" << endl;
    // 为指针分配内存
    ptr_Line_CC_B = new int;
    cout << "1.1--内存" << ptr_Line_CC_B << "\t\n" << endl;
    *ptr_Line_CC_B = len_CC_B;
    cout << "1.2--形参" << len_CC_B << "\t\n" << endl;
    cout << "1.3--值域" << *ptr_Line_CC_B << "\t\n" << endl;
}

class_Line_CC_B::class_Line_CC_B(const class_Line_CC_B  &obj_cc)
{
    cout << "2--调用拷贝构造函数并为指针 ptr 分配内存" << "\t\n" << endl;
    ptr_Line_CC_B = new int;
    cout << "2.1--形参" << *obj_cc.ptr_Line_CC_B << "\t\n" << endl;
    *ptr_Line_CC_B = *obj_cc.ptr_Line_CC_B; // 拷贝值
    cout << "2.2--实参" << *ptr_Line_CC_B << "\t\n" << endl;
}

class_Line_CC_B::~class_Line_CC_B(void)
{
    cout << "3--释放内存" << "\t\n" << endl;
    cout << "3.1--形参  " << &ptr_Line_CC_B << "\t\n" << endl;
    delete ptr_Line_CC_B;
    cout << "3.2--实参  " << &ptr_Line_CC_B << "\t\n" << endl;
}

int class_Line_CC_B::getLength_Line_CC_B(void)
{
    cout << "4--getLength: \t" << *ptr_Line_CC_B << "\t\n" << endl;
    return *ptr_Line_CC_B;
}

void display_class_Line_CC_B(class_Line_CC_B    obj_cc)
{
    cout << "5--line 大小 : " << obj_cc.getLength_Line_CC_B() << "\t\n" << endl;
}

void display_copy_construction()
{
/*
拷贝构造函数是一种特殊的构造函数，它在创建对象时，
是使用同一类中之前创建的对象来初始化新创建的对象。拷贝构造函数通常用于：
通过使用另一个同类型的对象来初始化新创建的对象。
复制对象把它作为参数传递给函数。
复制对象，并从函数返回这个对象。

如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，
并有动态内存分配，则它必须有一个拷贝构造函数。拷贝构造函数的最常见形式如下：
classname (const classname &obj) 
{
   // 构造函数的主体
}
*/

    cout << "*-------------开始-------------*" << "\n"<< endl;
    class_Line_CC_B     Line_CC_B(1234);
    cout << "*-------------显示1-------------*" << "\n" << endl;
    display_class_Line_CC_B(Line_CC_B);
    cout << "*-------------中间-------------*" << "\n" << endl;
    class_Line_CC_B     Line_CC_BB= Line_CC_B;
    cout << "*-------------显示2-------------*" << "\n" << endl;
    display_class_Line_CC_B(Line_CC_BB);
    cout << "*-------------结束-------------*" << "\n" << endl;
;
}




class class_Line_A
{
   public:
      void   setLength_Line_A(double len);
      double getLength_Line_A(void);
      class_Line_A(double len);  // 这是构造函数
      ~class_Line_A();           // 这是析构函数声明
      //类的构造函数是一种特殊的函数，在创建一个新的对象时调用。
      //类的析构函数也是一种特殊的函数，在删除所创建的对象时调用。
   private:
      double length;
};

class_Line_A::class_Line_A(double len)
{
    // 成员函数定义，包括构造函数
    cout << "*---成员函数定义，包括构造函数---* \t"<< endl;
    cout << "1--Object is being created, len    = " << len    << "\n" <<endl;
    length = len;
    cout << "2--Object is being created, length = " << length << "\n" << endl;
}

class_Line_A::~class_Line_A(void)
{
    cout << "****---> 析构函数 <---****" << endl;
    cout << "5--Object is being deleted" << endl;
}

void class_Line_A::setLength_Line_A(double len)
{
    length = len;
    cout << "3--Object is being created, length = " << length << "\n" << endl;
}

double class_Line_A::getLength_Line_A(void)
{
    cout << "4--Object is being created, length = " << length << "\n" << endl;
    return length;
}

void display_Constructor_destructor()
{
    class_Line_A         Line_A(110.0);

    // 获取默认设置的长度
    cout << "获取默认长度    -->    Length of line : " << Line_A.getLength_Line_A() << " \t <---- \n"<< endl;
    // 再次设置长度
    Line_A.setLength_Line_A(16.0);
    cout << "再次设置长度    -->    Length of line : " << Line_A.getLength_Line_A() << " \t <---- \n" << endl;

    // 设置长度
    Line_A.setLength_Line_A(26.0);
    cout << "#设置长度#    -->    Length of line : " << Line_A.getLength_Line_A() << " \t <---- \n" << endl;
}



class Box_class1
{
    public:
        double      length;   // 长度
        double      breadth;  // 宽度
        double      height;   // 高度

        double      length_pub4;   // 长度
        void        setWidth_pub4(double wid);
        double      getWidth_pub4(void);

        // 成员函数声明
        double      box3_get(void);
        void        box3_set(double len, double bre, double hei);
        void        setLength(double len);
        void        setBreadth(double bre);
        void        setHeight(double hei);


    private:
        double      width_pri4;


    protected:
        double      width_pro5;


};

class Box_class1_A 
{
    // public 继承
    public:
        int A_pub_a;
        Box_class1_A()
        {
            cout << "Box_class1_A-A \t" << endl;   //正确
            A_pub_a1 = 11;
            cout << "A_pub_CA_a1 \t" << A_pub_a1 << endl;   //正确
            A_pub_a2 = 12;
            cout << "A_pub_CA_a2 \t" << A_pub_a2 << endl;   //正确
            A_pub_a3 = 13;
            cout << "A_pub_CA_a3 \t" << A_pub_a3 << endl;   //正确
            A_pub_a = 14;
            cout << "A_pub_CA_a    \t" << A_pub_a << endl;       //正确
            cout << "\n"<< endl;
        }
        void fun_A() 
        {
            cout << "A_pub_a0_F \t" << A_pub_a  << endl;       //正确
            cout << "A_pub_a1_F \t" << A_pub_a1 << endl;   //正确
            cout << "A_pub_a2_F \t" << A_pub_a2 << endl;   //正确
            cout << "A_pub_a3_F \t" << A_pub_a3 << endl;   //正确
            cout << "\n" << endl;
        }
    public:
        int A_pub_a1;
    protected:
        int A_pub_a2;
    private:
        int A_pub_a3;
};

class Box_class1_B : public Box_class1_A
{
    public:
        int B_pub_a;
        Box_class1_B(int er_i)
        {
            cout << "Box_class1_A-公共继承 \t" << endl;
            Box_class1_A();
            B_pub_a = er_i;
            cout << "class1_B-public-class1_A \t" << B_pub_a << endl;   //正确
            cout << "\n" << endl;
        }
        void fun_B() 
        {
            cout << "B_pub_a_F \t" <<  A_pub_a << endl;         //正确，public成员
            cout << "B_pub_a0_F \t" << A_pub_a1 << endl;       //正确，基类的public成员，在派生类中仍是public成员。
            cout << "B_pub_a2_F \t" << A_pub_a2 << endl;       //正确，基类的protected成员，在派生类中仍是protected可以被派生类访问。
            //cout << "B_pub_a3_F \t" << A_pub_a3 << endl;       //错误，基类的private成员不能被派生类访问。
            cout << "B_pub_a_F-B_pub_a \t" << B_pub_a << endl;          //正确，public成员
        }
};

class Box_class1_B_pro : protected Box_class1_A
{
public:
    int B_pro_a;
    Box_class1_B_pro(int B_pro_i)
    {
        cout << "Box_class1_A-保护继承 \t" << endl;
        Box_class1_A();
        B_pro_a = B_pro_i;
        cout << "class1_B_pro-protected-class1_A \t" << B_pro_a << endl;   //正确
        cout << "\n" << endl;
    }
    void fun_B_pro() 
    {
        cout << "B_pro_a0 \t" << B_pro_a << endl;       //正确，public成员。
        cout << "B_pro_a1 \t" << A_pub_a1 << endl;       //正确，基类的public成员，在派生类中变成了protected，可以被派生类访问。
        cout << "B_pro_a2 \t" << A_pub_a2 << endl;       //正确，基类的protected成员，在派生类中还是protected，可以被派生类访问。
        //cout << "B_pro_a3 \t" << A_pub_a3 << endl;       //错误，基类的private成员不能被派生类访问。
    }
};

class Box_class1_B_pri  : private Box_class1_A 
{
    public:
      int B_pri_a;
      Box_class1_B_pri(int  B_pri_i)
      {
            cout << "Box_class1_A-私有继承 \t" << endl;
            Box_class1_A();
            B_pri_a = B_pri_i;
            cout << "class1_B_pro-protected-class1_A \t" << B_pri_a << endl;   //正确
            cout << "\n" << endl;
      }
      void fun_B_pri()
      {
        cout << "B_pri_a0 \t" << B_pri_a << endl;       //正确，public成员。
        cout << "B_pri_a0 \t" << A_pub_a1 << endl;       //正确，基类public成员,在派生类中变成了private,可以被派生类访问。
        cout << "B_pri_a0 \t" << A_pub_a2 << endl;       //正确，基类的protected成员，在派生类中变成了private,可以被派生类访问。
        //cout << "B_pri_a0 \t" << A_pub_a3 << endl;       //错误，基类的private成员不能被派生类访问。
      }
};

class SmallBox :Box_class1 
{
    // SmallBox 是派生类
public:
    void    setSmallWidth_pro5(double wid);
    double  getSmallWidth_pro5(void);
};

double SmallBox::getSmallWidth_pro5(void)
{
    return width_pro5;    // 子类的成员函数
}

void SmallBox::setSmallWidth_pro5(double wid)
{
    width_pro5 = wid;
}

double Box_class1::getWidth_pub4(void)
{
    return      width_pri4;    // 成员函数定义
}

void Box_class1::setWidth_pub4(double wid)
{
    width_pri4 = wid;
}

double Box_class1::box3_get(void)
{
    //Class::Method 是类 Class 中的方法 Method 的意思，常用于在 class 块外定义方法。（声明在内）
    // 成员函数定义
    return      length * breadth * height;
}

void Box_class1::box3_set(double len, double bre, double hei)
{
    length  = len;
    breadth = bre;
    height  = hei;
}

void Box_class1::setLength(double len)
{
    length = len;
}

void Box_class1::setBreadth(double bre)
{
    breadth = bre;
}



void Box_class1::setHeight(double hei)
{
    height = hei;
}

void display_class_object_mode()
{
#if 0
    // C++ 类& 对象
    // C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。
    // 类是 C++ 的核心特性，通常被称为用户定义的类型。
    // 类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。
    // 类中的数据和方法称为类的成员。函数在一个类中被称为类的成员。
    class  classname
    {
        access    specifiers :    // 访问修饰符：private/public/protected
            data    members / variables;    // 变量
            member  functions() {}           // 方法
    };

    // 数据封装是面向对象编程的一个重要特点，它防止函数直接访问类类型的内部成员。
    // 类成员的访问限制是通过在类主体内部对各个区域标记 public、private、protected 
    // 来指定的。关键字 public、private、protected 称为访问修饰符。
    // 一个类可以有多个 public、protected 或 private 标记区域。
    // 每个标记区域在下一个标记区域开始之前或者在遇到类主体结束右括号之前都是有效的。
    // 成员和类的默认访问修饰符是 private。
    class Base 
    {
        public:
            // 公有成员 
            // 公有成员在程序中类的外部是可访问的。
        protected:
            // 受保护成员
            // 私有成员变量或函数在类的外部是不可访问的，甚至是不可查看的。
            // 只有类和友元函数可以访问私有成员。
            // 默认情况下，类的所有成员都是私有的。例如在下面的类中，
            // width 是一个私有成员，这意味着，如果您没有使用任何访问修饰符，
            // 类的成员将被假定为私有成员：
        private:
            // 私有成员
    };
    //protected（受保护）成员
    //protected（受保护）成员变量或函数与私有成员十分相似，但有一点不同，protected
    //（受保护）成员在派生类（即子类）中是可访问的。在下一个章节中，您将学习到派生类
    // 和继承的知识。现在您可以看到下面的实例中，我们从父类 Box 派生了一个子类 smallBox。
    // 下面的实例与前面的实例类似，在这里 width 成员可被派生类 smallBox 的任何成员函数访问。

    //继承中的特点
    //有public, protected, private三种继承方式，它们相应地改变了基类成员的访问属性。
    //1.public 继承：基类 public 成员，protected 成员，private 成员的访问属性
    //在派生类中分别变成：public, protected, private
    //2.protected 继承：基类 public 成员，protected 成员，private 成员的访问属性
    //在派生类中分别变成：protected, protected, private
    //3.private 继承：基类 public 成员，protected 成员，private 成员的访问属性
    //在派生类中分别变成：private, private, private
    //但无论哪种继承方式，上面两点都没有改变：
    //1.private 成员只能被本类成员（类内）和友元访问，不能被派生类访问；
    //2.protected 成员可以被派生类访问。


#endif

    Box_class1      Box1;        // 声明 Box1，类型为 Box
    Box_class1      Box2;        // 声明 Box2，类型为 Box
    Box_class1      Box3;        // 声明 Box3，类型为 Box
    Box_class1      Box4;        // pri 私有
    SmallBox        Box5;        // pro 受保护 - 派生类
    double volume = 0.0;     // 用于存储体积


    //---------------------------------------------------------------------------12//
    // 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 << "\n" << endl;
    // box 2 的体积
    volume = Box2.height * Box2.length * Box2.breadth;
    cout << "Box2 的体积：" << volume << "\n" << endl;
    //---------------------------------------------------------------------------3//
    // 
    // box 3 详述
    Box3.box3_set(16.0, 8.0, 12.0);
    volume = Box3.box3_get();
    // 需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。
    cout << "Box3 的体积：" << volume << "\n" << endl;

    //---------------------------------------------------------------------------4//
    // 不使用成员函数设置长度
    Box4.length_pub4 = 444.0; // OK: 因为 length 是公有的
    cout << "Length of box4 : " << Box4.length_pub4 << "\n" << endl;

    // 不使用成员函数设置宽度
    //Box4.width_pri4 = 10.0; // Error: 因为 width 是私有的
     cout << "Width of box4 : " << Box4.getWidth_pub4() << "\n" << endl;
     Box4.setWidth_pub4(4442.0);  // 使用成员函数设置宽度
     cout << "Width of box4 : " << Box4.getWidth_pub4() << "\n" << endl;

     //---------------------------------------------------------------------------5//
     // 使用成员函数设置宽度
     Box5.setSmallWidth_pro5(555.0);
     cout << "Width of box5 : " << Box5.getSmallWidth_pro5() << "\n" << endl;


     //---------------------------------------------------------------------------6//
     // public 继承
     cout << "public 继承*-----------------6----------------* \n" << endl;
     Box_class1_B       derive_b(666);
     cout << "derive_b.A_pub_a  :" << derive_b.A_pub_a   << "\n" << endl;
     cout << "derive_b.B_pub_a  :" << derive_b.B_pub_a   << "\n" << endl;
     cout << "derive_b.A_pub_a1:" << derive_b.A_pub_a1   << "\n" << endl;   //正确
     //cout <<  derive_b.A_pub_a2 << endl;   //错误，类外不能访问protected成员
     //cout <<  derive_b.A_pub_a3<< endl;   //错误，类外不能访问private成员
     
     //---------------------------------------------------------------------------7//
     // protected 继承
     cout << "protected 继承*-----------------7----------------* \n" << endl;
     Box_class1_B_pro       derive_pro_b(777);
     cout << "B_pro_a \t" << derive_pro_b.B_pro_a << "\n"<< endl;       //正确。public成员
     //cout << derive_pro_b.a1 << endl;      //错误，protected成员不能在类外访问。
     //cout << derive_pro_b.a2 << endl;      //错误，protected成员不能在类外访问。
     //cout << derive_pro_b.a3 << endl;      //错误，private成员不能在类外访问。
     
     //---------------------------------------------------------------------------8//
     // private 继承
     cout << "protected 继承*-----------------8----------------* \n" << endl;
     Box_class1_B_pro       derive_pri_b(8888);
     cout << derive_pri_b.B_pro_a << endl;       //正确。public成员
     //cout << derive_pri_b.a1 << endl;      //错误，private成员不能在类外访问。
     //cout << derive_pri_b.a2 << endl;      //错误, private成员不能在类外访问。
     //cout << derive_pri_b.a3 << endl;      //错误，private成员不能在类外访问。
     system("pause");

}

//--------------------------------------基础--------------------------------------//
void display_struct_data_printBook(struct  Books  book)
{
    cout << "\n" << endl;
    cout << "书标题 : " <<  book.title    << endl;
    cout << "书作者 : " <<  book.author   << endl;
    cout << "书类目 : " <<  book.subject  << endl;
    cout << "书 ID  : " <<  book.book_id  << endl;
    cout << "\n" << endl;
}

void display_struct_data_printBook2(struct  Books  *book)
{
    // 该函数以结构指针作为参数
    cout << "\n" << endl;
    cout << "书标题  : " << book->title   << endl;
    cout << "书作者  : " << book->author  << endl;
    cout << "书类目  : " << book->subject << endl;
    cout << "书 ID   : " << book->book_id << endl;
    cout << "\n" << endl;
}

void display_struct_data()
{
    Books    Book1;        // 定义结构体类型 Books 的变量 Book1
    Books    Book2;        // 定义结构体类型 Books 的变量 Book2
    Books    Book3;        // 定义结构体类型 Books 的变量 Book3
    Books    Book4;        // 定义结构体类型 Books 的变量 Book4
    Books    Book5;        // 定义结构体类型 Books 的变量 Book5
    Books    Book6;        // 定义结构体类型 Books 的变量 Book6

    //-------------------------------------------------------------12//
    // Book1 详述
    strcpy(Book1.title, "C++ 教程1");
    strcpy(Book1.author, "Runoob1");
    strcpy(Book1.subject, "编程语言1");
    Book1.book_id = 12345;
   
    // Book2 详述
    strcpy(Book2.title, "CSS 教程2");
    strcpy(Book2.author, "Runoob2");
    strcpy(Book2.subject, "前端技术2");
    Book2.book_id = 12346;
    
    // 输出 Book1 信息
    cout << "第一本书标题 : " << Book1.title << endl;
    cout << "第一本书作者 : " << Book1.author << endl;
    cout << "第一本书类目 : " << Book1.subject << endl;
    cout << "第一本书 ID : " << Book1.book_id << endl;
    cout << "\n" << endl;
    // 输出 Book2 信息
    cout << "第二本书标题 : " << Book2.title << endl;
    cout << "第二本书作者 : " << Book2.author << endl;
    cout << "第二本书类目 : " << Book2.subject << endl;
    cout << "第二本书 ID : " << Book2.book_id << endl;
    cout << "\n" << endl;
    //-------------------------------------------------------------34//
    // Book1 详述
    strcpy(Book3.title, "C++ 教程13");
    strcpy(Book3.author, "Runoob13");
    strcpy(Book3.subject, "编程语言13");
    Book3.book_id = 12345;

    // Book2 详述
    strcpy(Book4.title, "CSS 教程24");
    strcpy(Book4.author, "Runoob24");
    strcpy(Book4.subject, "前端技术24");
    Book4.book_id = 12346;

    // 输出 Book3 信息
    display_struct_data_printBook(Book3);
    // 输出 Book4 信息
    display_struct_data_printBook(Book4);
    //-------------------------------------------------------------56//
     // Book1 详述
    strcpy(Book1.title, "C++ 教程5");
    strcpy(Book1.author, "Runoob5");
    strcpy(Book1.subject, "编程语言5");
    Book1.book_id = 12345;

    // Book2 详述
    strcpy(Book2.title, "CSS 教程6");
    strcpy(Book2.author, "Runoob6");
    strcpy(Book2.subject, "前端技术6");
    Book2.book_id = 12346;

    // 通过传 Book1 的地址来输出 Book1 信息
    display_struct_data_printBook2(&Book1);
    // 通过传 Book2 的地址来输出 Book2 信息
    display_struct_data_printBook2(&Book2);
}

void diaplay_input_output_data()
{
    static char df_str[] = "Hello C++";
    // 标准输出流（cout）预定义的对象 cout 是 iostream 类的一个实例。
    // cout 对象"连接"到标准输出设备，通常是显示屏。cout 是与流插入运算符 << 结合使用的，
    cout << "Value of str is : " << df_str << endl;

    //标准输入流（cin）
    // 预定义的对象 cin 是 iostream 类的一个实例。cin 对象附属到标准输入设备，通常是键盘。
    // cin 是与流提取运算符 >> 结合使用的，如下所示：
    static char df_name[50];

    cout << "请输入您的名称： ";
    cin >> df_name;
    cout << "您的名称是： " << df_name << endl;

    //标准错误流（cerr）
    // 预定义的对象 cerr 是 iostream 类的一个实例。cerr 对象附属到标准输出设备，
    // 通常也是显示屏，但是 cerr 对象是非缓冲的，且每个流插入到 cerr 都会立即输出。
    //  cerr 也是与流插入运算符 << 结合使用的，如下所示：
    char df_str2[] = "Unable to read....";

    cerr << "Error message : " << df_str2 << endl;
    //标准日志流（clog）
    // 预定义的对象 clog 是 iostream 类的一个实例。clog 对象附属到标准输出设备，
    // 通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。
    // clog 也是与流插入运算符 << 结合使用的，
    clog << "Error message : " << df_str2 << endl;


}

void diaplay_time_data()
{
#if 0
    struct tm_time {
        int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
        int tm_min;   // 分，范围从 0 到 59
        int tm_hour;  // 小时，范围从 0 到 23
        int tm_mday;  // 一月中的第几天，范围从 1 到 31
        int tm_mon;   // 月，范围从 0 到 11
        int tm_year;  // 自 1900 年起的年数
        int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
        int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
        int tm_isdst; // 夏令时
}
#endif
    // 基于当前系统的当前日期/时间
    time_t now = time(0);

    // 把 now 转换为字符串形式
    char *dt = ctime(&now);

    cout << "本地日期和时间：" << dt << endl;

    // 把 now 转换为 tm 结构
    tm *gmtm = gmtime(&now);
    dt = asctime(gmtm);
    cout << "UTC 日期和时间：" << dt << endl;

    // 基于当前系统的当前日期/时间
    time_t now2 = time(0);

    cout << "1970 到目前经过秒数:" << now2 << endl;

    tm *ltm = localtime(&now2);

    // 输出 tm 结构的各个组成部分
    cout << "年  : " << 1900 + ltm->tm_year << endl;
    cout << "月  : " << 1 +    ltm->tm_mon  << endl;
    cout << "日  : " <<        ltm->tm_mday << endl;
    cout << "时间: " <<        ltm->tm_hour << ":"<< ltm->tm_min << ":"<< ltm->tm_sec << endl;
}

void display_quote()
{
#if 0
    // 引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。
    // 一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

    // C++ 引用 vs 指针:引用很容易与指针混淆，它们之间有三个主要的不同：
    // 不存在空引用。引用必须连接到一块合法的内存。
    // 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
    // 引用必须在创建时被初始化。指针可以在任何时间被初始化。
#endif
    // 声明简单的变量
    static int    we_i;
    static double we_d;

    // 声明引用变量
    static int&    we_r = we_i;
    static double& we_s = we_d;

    we_i = 5;
    cout << "Value of i : " << we_i << endl;
    cout << "Value of i reference : " << we_r << endl;

    we_d = 11.7;
    cout << "Value of d : " << we_d << endl;
    cout << "Value of d reference : " << we_s << endl;
}

int *getRandom()
{
    // 要生成和返回随机数的函数
    static int  rty_r[10];
    srand((unsigned long)time(NULL));                        // 设置种子
    for (int indec_E = 0; indec_E < 10; indec_E++ )
    {
        rty_r[indec_E] = rand();
        cout << "\t"<< indec_E << "\t" << rty_r[indec_E] << endl;
    }

    return rty_r;
}

void display_Pointer_func_get()
{
    static  int  * rty_p;

    rty_p = getRandom();
    for (int indec_F = 0; indec_F < 10; indec_F++)
    {
        cout << "*(rty_p + " << indec_F << ") : " << *(rty_p + indec_F) << endl;
    }
}

double display_Pointer_getAverage(int* rt_arr, int rt_size)
{
    static  int    rt_i, rt_sum = 0;
    static  double avg;

    for (rt_i = 0;  rt_i < rt_size;  rt_i++)
    {
        cout << "\t" << "rt_i: " << "\t" << rt_i <<  endl;
        rt_sum += rt_arr[rt_i];
        cout << "rt_arr[rt_i]: " << rt_arr[rt_i] << endl;
        cout << "rt_sum      : " << rt_sum << endl;

    }
    cout << "\n" << endl;
    avg = double(rt_sum) / rt_size;
    
    cout << "Average value is: " << avg << endl;  // 输出返回值

    return avg;
}

void display_Pointer_opration_getSeconds(unsigned long *par_sec_seconds)
{
    *par_sec_seconds = time(NULL); // 获取当前的秒数
    cout << "Number of seconds :" << *par_sec_seconds << endl; // 输出实际值
    return;
}

void display_MultPointer_opration()
{
    // 指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。
    // 指针的指针就是将指针的地址存放在另一个指针里面。通常，一个指针包含一个变量的地址。
    // 当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
    // 一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。 int **var;
    static  int     wer_var;
    static  int     * wer_ptr;
    static  int     ** wer_pptr;
    wer_var  = 12345;
    wer_ptr  = &wer_var;            // 获取 var 的地址
    wer_pptr = &wer_ptr;            // 使用运算符 & 获取 ptr 的地址

    // 使用 pptr 获取值
    cout << "var    值为:" << wer_var    << &wer_var      << endl;
    cout << "*ptr   值为:" << *wer_ptr   << &(*wer_ptr)   << endl;
    cout << "**pptr 值为:" << **wer_pptr << &(**wer_pptr) << endl;
}

void display_pointer_opration()
{
    static   int  var1;
    static   int  var2[10];
    static   int  index_var2;
    static   int  *ptr_var2;
    static   int  var_real = 20;                        // 实际变量的声明
    // 指针变量声明的一般形式为：type *var-name;
    static   int  *pointer_statement;                   // 指针变量的声明
    static   int  *ptr_statement = NULL;

    const    int   MAX_Q = 10;
    static   int   var_array4[MAX_Q] = { 10, 50, 100, 200, 300, 99, 55, 33, 11, 1};
    static   int   var_array5[MAX_Q] = { 10, 50, 100, 200, 300, 99, 55, 33, 11, 1};
    static   int   *ptr_var_array5[MAX_Q];
    static   int   *ptr_state_max;
    const    char  *names[MAX_Q] = {"Zara Ali","Hina Ali","Nuha Ali","Sara Ali",};



    //1------------------------------------------------------------------
    cout << "\n\t" "1" "\t\n" << endl;
    cout << "var1 变量的地址： " << &var1 << endl;
    cout << "var2 变量的地址： " << &var2 << endl;
    ptr_var2 = var2;
    for (index_var2 = 0; index_var2 < 10; index_var2++)
    {
         cout << "var2 数组遍历地址：" << index_var2 << endl;
         cout << "Address of var   ["  << index_var2 << "] = " << ptr_var2 << endl;
         cout << "Value   of var   ["  << index_var2 << "] = " << *ptr_var2 << endl;
         ptr_var2++;
    }
    
    //2------------------------------------------------------------------
    cout << "\n\t" "2" "\t\n" << endl;
    pointer_statement = &var_real;       
    cout << "Value of var variable        : " <<  var_real           << endl; // 在指针变量中存储 var 的地址
    cout << "Address stored in ip variable: " <<  pointer_statement  << endl; // 输出在指针变量中存储的地址
    cout << "Value of *ip variable        : " << *pointer_statement  << endl;         // 访问指针中地址的值


    //3------------------------------------------------------------------
    // 在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为空指针。
    // NULL 指针是一个定义在标准库中的值为零的常量。
    cout << "\n\t" "3" "\t\n" << endl;
    cout << "ptr 的地址是 " <<  pointer_statement    << endl;
    cout << "ptr 的值是 "   << *pointer_statement    << endl;
    cout << "\n" << endl;

    //4------------------------------------------------------------------
    // 指针中的数组地址
    cout << "\n\t" "4" "\t\n" << endl;
    ptr_state_max = var_array4;
    cout << "\n --递增" << endl;
    for (int index_A = 0; index_A < MAX_Q; index_A++)
    {
        cout << "Address of var[" << index_A << "] = "  <<   ptr_state_max  << endl;
        cout << "Value   of var[" << index_A << "] = "  <<  *ptr_state_max  << endl;
        ptr_state_max++; // 移动到下一个位置
    }
    cout << "\n --递减" << endl;
    for (int index_A = MAX_Q; index_A > 0; index_A--)
    {
        ptr_state_max--; // 移动到下一个位置
        cout << "Address of var[" << index_A << "] = " << ptr_state_max << endl;
        cout << "Value   of var[" << index_A << "] = " << *ptr_state_max << endl;
    }
    cout << "\n" << endl;

    //5------------------------------------------------------------------
    cout << "\n\t" "5" "\t\n" << endl;
    for (int index_B = 0; index_B < MAX_Q; index_B++)
    {
        cout << "Value of var[" << index_B << "] = ";
        cout << var_array5[index_B] << endl;
    }
    cout << "\n" << endl;
    
    // int* ptr[MAX];
    // 把 ptr 声明为一个数组，由 MAX 个整数指针组成。因此，ptr 中的每个元素，都是一个指向
    // int 值的指针。下面的实例用到了三个整数，它们将存储在一个指针数组中，*ptr_var_array5
    for (int index_C = 0; index_C < MAX_Q; index_C++)
    {
        ptr_var_array5[index_C] = &var_array5[index_C]; // 赋值为整数的地址
        cout << "赋值为整数的地址：Value [ " << index_C << " ] = " << *ptr_var_array5[index_C] << endl;
    }
    // 指向字符的指针数组来存储一个字符串列表
    cout << "\n" << endl;
    for (int index_D = 0; index_D < 3; index_D++)  // 目前是3个定义数据
    {
        cout << "Value of names[" << index_D << "] = " << names[index_D] << endl;
    }
} 

void display_string_opration()
{
    static char qwe_site[7]  = { 'R', 'U', 'N', 'O', 'O', 'B', '\0' };
    static char qwe_str1[13] = "runoob" ;
    static char qwe_str2[13] = "google" ;
    static char qwe_str3[23];
    static int  qwe_len;

    cout << "菜鸟教程: "<< qwe_site << endl;

    // 复制 str1 到 str3
    strcpy(qwe_str3, qwe_str1);
    cout << " strcpy( str3, str1) :  " << qwe_str3 << endl;

    // 连接 str1 和 str2
     strcat(qwe_str1, qwe_str2);
    cout << "strcat( str1, str2): " << qwe_str1 << endl;

    // 连接后，str1 的总长度
    qwe_len = strlen(qwe_str1);
    //cout << "strlen(str1) : " << qwe_len << endl;
}

void display_array()
{
    int array_N[20]; // n 是一个包含 10 个整数的数组

    // 初始化数组元素          
    for (int index_A = 0; index_A < 20; index_A++)
    {
        array_N[index_A] = index_A*5 + 100; // 设置元素 index_A 为 index_A + 100
    }
    cout << " Element" << setw(20) << "Value" << endl;

    // 输出数组中每个元素的值                     
    for (int index_A = 0; index_A < 20; index_A++)
    {
        cout << setw(5) << index_A << setw(22) << array_N[index_A] << endl;
    }
}

void display_func(void)
{
    static int ASD_Count = 5; // 局部静态变量
    ASD_Count++;
    std::cout << "变量 ASD_Count 为 " << ASD_Count;
    std::cout << " , 变量 ASD_Count 为 " << ZXC_count << std::endl;
}

void display_const_value()
{
    const int  LENGTH_C = 3;
    const int  WIDTH_C = 4;
    const char NEWLINE_C = '\n';
    int AREA_C;

    AREA_C = LENGTH_C * WIDTH_C;
    cout << AREA_C;
    cout << NEWLINE;
}

void display_define_value()
{
    static int area;

    area = LENGTH * WIDTH;
    cout << area <<endl;
    cout << NEWLINE <<endl;
}

void display_string_constant()
{
    string greeting = "hello, runoob";
    cout << greeting << endl;

    

    string greeting2 ="hello, runoob";
    cout << greeting2 <<endl;
}

void display_calculation()
{
    // 变量定义
   static int a, b;
   static int c;
   static float f;

    // 实际初始化
    a = 10;
    b = 20;
    c = a + b;

    cout << c << endl;

    f = 70/ 3;
    cout << f << endl;
}

void display_data_type()
{
        cout << "type: \t\t" << "************size**************" << endl;
        cout << "bool: \t\t" << "所占字节数：" << sizeof(bool);        // sizeof() 运算符用来获取各种数据类型的大小。
        cout << "\t最大值：" << (numeric_limits<bool>::max)();
        cout << "\t\t最小值：" << (numeric_limits<bool>::min)() << endl;
        cout << "char: \t\t" << "所占字节数：" << sizeof(char);
        cout << "\t最大值：" << (numeric_limits<char>::max)();
        cout << "\t\t最小值：" << (numeric_limits<char>::min)() << endl;
        cout << "signed char: \t" << "所占字节数：" << sizeof(signed char);
        cout << "\t最大值：" << (numeric_limits<signed char>::max)();
        cout << "\t\t最小值：" << (numeric_limits<signed char>::min)() << endl;
        cout << "unsigned char: \t" << "所占字节数：" << sizeof(unsigned char);
        cout << "\t最大值：" << (numeric_limits<unsigned char>::max)();
        cout << "\t\t最小值：" << (numeric_limits<unsigned char>::min)() << endl;
        cout << "wchar_t: \t" << "所占字节数：" << sizeof(wchar_t);
        cout << "\t最大值：" << (numeric_limits<wchar_t>::max)();
        cout << "\t\t最小值：" << (numeric_limits<wchar_t>::min)() << endl;
        cout << "short: \t\t" << "所占字节数：" << sizeof(short);
        cout << "\t最大值：" << (numeric_limits<short>::max)();
        cout << "\t\t最小值：" << (numeric_limits<short>::min)() << endl;
        cout << "int: \t\t" << "所占字节数：" << sizeof(int);
        cout << "\t最大值：" << (numeric_limits<int>::max)();
        cout << "\t最小值：" << (numeric_limits<int>::min)() << endl;
        cout << "unsigned: \t" << "所占字节数：" << sizeof(unsigned);
        cout << "\t最大值：" << (numeric_limits<unsigned>::max)();
        cout << "\t最小值：" << (numeric_limits<unsigned>::min)() << endl;
        cout << "long: \t\t" << "所占字节数：" << sizeof(long);
        cout << "\t最大值：" << (numeric_limits<long>::max)();
        cout << "\t最小值：" << (numeric_limits<long>::min)() << endl;
        cout << "unsigned long: \t" << "所占字节数：" << sizeof(unsigned long);
        cout << "\t最大值：" << (numeric_limits<unsigned long>::max)();
        cout << "\t最小值：" << (numeric_limits<unsigned long>::min)() << endl;
        cout << "double: \t" << "所占字节数：" << sizeof(double);
        cout << "\t最大值：" << (numeric_limits<double>::max)();
        cout << "\t最小值：" << (numeric_limits<double>::min)() << endl;
        cout << "long double: \t" << "所占字节数：" << sizeof(long double);
        cout << "\t最大值：" << (numeric_limits<long double>::max)();
        cout << "\t最小值：" << (numeric_limits<long double>::min)() << endl;
        cout << "float: \t\t" << "所占字节数：" << sizeof(float);
        cout << "\t最大值：" << (numeric_limits<float>::max)();
        cout << "\t最小值：" << (numeric_limits<float>::min)() << endl;
        cout << "size_t: \t" << "所占字节数：" << sizeof(size_t);
        cout << "\t最大值：" << (numeric_limits<size_t>::max)();
        cout << "\t最小值：" << (numeric_limits<size_t>::min)() << endl;
        cout << "string: \t" << "所占字节数：" << sizeof(string) << endl;
        // << "\t最大值：" << (numeric_limits<string>::max)() << "\t最小值：" << (numeric_limits<string>::min)() << endl;  
        cout << "type: \t\t" << "************size**************" << endl;
}

int main()
{
    //  endl，这将在每一行后插入一个换行符，<< 运算符用于向屏幕传多个值，
    cout << "Hello, world!" << endl;  
    cout << "\n" << endl;
    //display_data_type();
    //display_calculation();
    //display_string_constant();
    //display_define_value();
    //display_const_value();
    /*  while (ZXC_count--){display_func();}  */
    //display_array();
    //display_string_opration();
    //display_pointer_opration();
    //display_MultPointer_opration();
    //display_Pointer_opration_getSeconds(&sec_seconds);
    //display_Pointer_getAverage(rt_balance,5);
    //display_Pointer_func_get();
    //display_quote();
    //diaplay_time_data();
    //diaplay_input_output_data();
    //display_struct_data();
    //--------------------------------------------------------------------------//
    
    //display_class_object_mode();
    //display_Constructor_destructor();
    //display_copy_construction();
    //display_inherit();
    //display_heavy_load();
    //display_polymorphic();

    //
    //display_fstream_data();











    return 0;                          //  终止 main( )函数，并向调用进程返回值 0
}

高级技能后续更新