关于class 与析构函数。构造函数，多重构造函数，

1 class 的观念是 struct的进阶；

class 类的名称{

  public：
 protected:

private:
}

 这东西叫属性；

 关于protected;他只能被继承所用；用法如下；

1: 1>F:\代码数据\class\class.cpp(24,11): error C2853: “f”: 非静态数据成员不能具有包含“auto”的类型;

class {  privte: auto f;}.非静态数据不能用auto;

 2; 1>F:\代码数据\class\class.cpp(18,1): error C2334: “{”的前面有意外标记；跳过明显的函数体;

//class die_fr {
//public:
//    die_fr{
//        //构造函数；
//     }
//     ~die_fr{
//        //析构函数；
//    }
//    die_fr(int f, die_fr) {
//        //可能是这个问题；
//    }
//protected://无限制只能被继承使用；
//{
//    int numg_y;
//}

//private:
//    int ad_num;
//    // f; v静态的数据不能包括auto;
prateive:
//};
//class JICHENG_DIE_FR : public die_fr {
//public:
//};

解决问题： 不会；应该问题出现在

构造函数

    一个程序类制动给程序中的成员函数赋值的东西，defaulit constructor; 可以自己进行定义； 

1 构造函数的名字与类名是相同的，假如class 的名字是Myclass ，那么构造函数Myclass();

 2 .对于构造函数来说，他们是不用进行返回值的，

3，构造函数是可以进行重载的，参数不同的，能够进行

 

 

关于＊this，与这个this－＞；

class spures {
    int a;
public:
    spures(int n) {
        a = n * n;
     }
    spures spr_unm(spures b) {///没见过啊。//嵌套一个类别。this->a =returnn *this;
        this->a = this->a + b.a;//类别进行嵌套类别；
        return *this;
    }
    int show_down() {
        cout << (*this).a << endl;
        return 0;
    }
};

关于*this .a 的解释：
      由于 . 的优先级高于* 的优先级。所以我们的加（）进行扩优先级，使用return *this　能够返回这个对象的当前内容。

静态的数据成员：
当类中的数据成员值被声明成静态的数据，该静态的值就将会被保留下来，直到下一次程序要改变这个值的数据；

　static 数据类型 数据名称；

在类的普通成员中，是不用设置初值的，但是static我们的要设置初值；但是要在类外设置；

class squrt_ion_tre {
public :
    squrt_ion_tre(char *pr_name_first,char *pc_name_first){
        pre_name = new char[strlen(pr_name_first) + 1];
         //构造函数的长度，然后将二者进行装填；
        // pre_name = pr_name_first;
        strcpy(pre_name, pr_name_first);
        pcolor = new char[strlen(pc_name_first) + 1];
        strcpy(pcolor, pc_name_first);
        id_sturent++;
     }
private:
    char* pre_name;
    char* pcolor;
    static int id_sturent;
public:

    int GET_SQURT_ION_TRE_NUM() {
        return id_sturent;
     }
    };
int squrt_ion_tre::id_sturent = 0;//静态数据；
int main() {
    squrt_ion_tre DI_FIRST("XIAOBIA", "XIAOHONG" );
    squrt_ion_tre DI_FIRST_SECOND("XIAOBIA", "XIAOHONG");
    
    cout << DI_FIRST.GET_SQURT_ION_TRE_NUM() << endl;
        return 0;
}

1>F:\代码数据\class\class.cpp(253,56): error C2664: “squrt_ion_tre::squrt_ion_tre(char *,char *)”: 无法将参数 1 从“const char [8]”转换为“char *”

1： 在项目中我们可以将项目属性中的c++语言中的语言——符合模式改为否；

2 使用强制类型转换；

class squrt_ion_tre {
public :
    squrt_ion_tre(const char *pr_name_first,const char *pc_name_first){
        pre_name = new char[strlen(pr_name_first) + 1];
         //构造函数的长度，然后将二者进行装填；
        // pre_name = pr_name_first;
        strcpy(pre_name, pr_name_first);
        pcolor = new char[strlen(pc_name_first) + 1];
        strcpy(pcolor, pc_name_first);
        id_sturent++;
     }
private:
    char* pre_name;
    char* pcolor;
    static int id_sturent;
public:

    int GET_SQURT_ION_TRE_NUM() {
        return id_sturent;
     }
    };
int squrt_ion_tre::id_sturent = 0;//静态数据；
int main() {
    const char* f = "xiaoming";
    squrt_ion_tre DI_FIRST(f, f );
    squrt_ion_tre DI_FIRST_SECOND(f, f);
    
    cout << DI_FIRST.GET_SQURT_ION_TRE_NUM() << endl;
        return 0;
}

 关于如何查看该类型，由于c++的类型审核较为严格。

我们 typeid().name;便可以进行查看；

int b=10;

 cout <<typeid(b).name<<endl; //结论为int；

1>F:\代码数据\class\class.cpp(232,5): message : 参见“squrt_ion_tre::squrt_ion_tre”的声明

 1>F:\代码数据\class\class.cpp(252,28): message : 从字符串文本转换将丢失 const 限定符(请参阅 /Zc:strictStrings)

1>F:\代码数据\class\class.cpp(236,9): error C4996: 'strcpy': This function or variable may be unsafe. Consider using strcpy_s instead. To disable deprecation, use _CRT_SECURE_NO_WARNINGS. See online help for details.
解决该问题：

 原因是由于strcpy 这个关键字已经被弃用，改为strcpy_s;这个函数。解决方案还有；#pragma warning(disable:4996) 加入这段话；

3，保护继承——protected;
                保护继承的特点是基类的所有公有成员和保护成员都成为派生类的保护成员，并且只能被它的派生类成员函数或友元访问，基类的私有成员仍然是私有的。

 

关于protected的使用例子； 只能被继承与友元函数进行使用；

public:公共成员； 可以进行内部，外部，继承,进行访问；

 private:私有成员，只能进行内部进行访问；

protected : 保护成员；能进行内部，继承使用。

eg:

class ABLE_OUT {
public:
    //构造函数；
    ABLE_OUT(std::string namep, std::string clss_neme) {
        //
     }
    void SHOW_OUT_PRTOUTED();
    //关于友元函数；
    friend void ABLEOUT_FIREND();
    //在上述的基类中PROTECTED的变量及其基类可以被继承进行使用；
    //友元函数也进行使用也可以；
    ~ABLE_OUT();

private:
    std::string namr_fg;
      // 非静态的可以进行定义？；
protected://保护函数；
    std::string name;
    std::string clss_neme_friend;
    int num_obj;
};

析构函数： 

1：为了防止某一些小可爱在class 中没有进行销毁成员函数的动态，自动加入delete进行销毁模式。防止动态资源被耗干；

2 ： 重载函数可以有多个。但是析构函数只有一个，并且在最后是自动调用delete；

3:关于析构函数的组成； ~加类名称；重载函数可以有多个不同类型。但是析构函数只有一个；

继承：

利用一个学生系统解释；

class Person
{
protected:
    string _name = "父类"; // 姓名
    int _num = 111; // 身份证号
};
class Student : public Person
{
public:
    void Print()
    {
        cout << "姓名:" << _name << endl;
        cout << "学号:" << _num << endl;
    }
protected:
    string _name = "子类"; // 姓名
};

继承：  同一个类进行派生出另一个类；