C ++: inicialización miembro de datos y la asignación

---

1. inicialización por defecto

#include <iostream>
#include <string>
using namespace std;
class A
{
public:
    int m;
    string s;
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m << endl;//类内内置类型未定义
    cout << a1.s << endl;//string默认初始化为空串
    cout << "----------------------------" << endl;
    return 0;
}

1. Cuando la clase no constructor de la clase y el valor inicial , el compilador se inicializa a los miembros de datos por defecto por un constructor predeterminado sintético.
2. Por defecto inicializado, las variables se les asigna un valor por defecto determinada por el tipo y la ubicación de la variable dentro del cuerpo de la función integrada de tipos y clases no se inicializan, es decir, sin definir.

2. El valor inicial de la clase (compilador no admite porción)

#include <iostream>
#include <string>
using namespace std;
class A
{
public:
    int m = 1;
    string s = "a";
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m << endl;
    cout << a1.s << endl;
    cout << "----------------------------" << endl;
    return 0;
}

1. Cuando la clase ningún constructor, pero hay clases valor inicial , el compilador síntesis constructor por defecto, utilizando el valor inicial para inicializar miembro de datos de la clase.

3. asignación dentro del constructor

#include <iostream>
#include <string>
using namespace std;
class A
{
public:
    A() //显式创建的构造函数
    {
        m = 2;
        s = "b";
    }
    int m = 1;
    string s = "a";
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m << endl;
    cout << a1.s << endl;
    cout << "----------------------------" << endl;
    return 0;
}

1. Creado explícitamente dentro de un constructor de la clase, la función de una asignación, los resultados cubrirá el inicializador de la clase.
2. Si los miembros son const, los tipos de referencia, o alguna de esta clase no se proporciona un constructor por defecto , sus miembros deben inicializar, puede no ser asignado el método.

4. lista de inicialización del constructor

#include <iostream>
#include <string>
using namespace std;
class B //不含默认构造函数
{
public:
    int n;
    B(int x) //默认构造函数无参数，此构造函数不是默认构造函数
    {
        n = x;
    }
};

class A
{
public:
    A() : m1(10), m2(20), r(m2), b(40) //显示创建的构造函数
    {
        m1 = 100;
    }
    int m1 = 1;
    const int m2 = 2;  //const
    const int &r = m1; //引用
    B b;               //未提供默认构造函数
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m1 << endl;
    cout << a1.m2 << endl;
    cout << a1.r << endl;
    cout << a1.b.n << endl;
    cout << "----------------------------" << endl;
    return 0;
}

1. Si los miembros son const, los tipos de referencia, o alguna de esta clase no se proporciona un constructor por defecto , sus miembros deben inicialización lista constructor inicializa.
2. Prioridad: la inicialización por defecto <inicializador de clase <inicialización de constructores de la lista <asignación de constructor. miembro de datos de valor es un valor de la cobertura de alta prioridad.

nota:

#include <iostream>
#include <string>
using namespace std;
class B //不含默认构造函数
{
public:
    int n;
    B(int x, int y) //默认构造函数无参数，此构造函数不是默认构造函数
    {
        n = x * y;
    }
};

class A //类内初始值
{
public:
    int m1 = 1;
    const int m2 = 2; //const
    int &r = m1;      //引用
    B b = B(3, 4);    //未提供默认构造函数
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m1 << " " << a1.m2 << " " << a1.r << " " << a1.b.n << endl;
    a1.m1 = 0; //m1是int，可修改
    // a1.m2 = 0; //错误，m2是const int，不可修改
    a1.r = 5;       //r引用m1，对r的修改实际是对m1的修改
    a1.b = B(0, 0); //b是类类型，可赋值修改
    cout << a1.m1 << " " << a1.m2 << " " << a1.r << " " << a1.b.n << endl;
    cout << "----------------------------" << endl;

    A a2, a3; //a2.m2和a3.m2不可修改，且总是相等
    cout << a2.m2 << endl;
    cout << a3.m2 << endl;
    cout << "----------------------------" << endl;
    return 0;
}

#include <iostream>
#include <string>
using namespace std;
class B //不含默认构造函数
{
public:
    int n;
    B(int x, int y) //默认构造函数无参数，此构造函数不是默认构造函数
    {
        n = x * y;
    }
};

class A //构造函数初始化列表
{
public:
    A() : m1(1), m2(2), r(m1), b(3, 4) {}                               //默认构造函数
    A(int i1, int i2, int x, int y) : m1(i1), m2(i2), r(m1), b(x, y) {} //普通构造函数

    int m1;
    const int m2; //const
    int &r;       //引用
    B b;          //未提供默认构造函数
};

int main()
{
    A a1;
    cout << "----------------------------" << endl;
    cout << a1.m1 << " " << a1.m2 << " " << a1.r << " " << a1.b.n << endl;
    a1.m1 = 0; //m1是int，可修改
    // a1.m2 = 0; //错误，m2是const int，不可修改
    a1.r = 5;       //r引用m1，对r的修改实际是对m1的修改
    a1.b = B(0, 0); //b是类类型，可赋值修改
    cout << a1.m1 << " " << a1.m2 << " " << a1.r << " " << a1.b.n << endl;
    cout << "----------------------------" << endl;

    A a2(1, 2, 3, 4), a3(10, 20, 30, 40); //a2.m2和a3.m2不可修改，但a2.m2和a3.m2可以不同
    cout << a2.m2 << endl;
    cout << a3.m2 << endl;
    cout << "----------------------------" << endl;
    return 0;
}

1. Cuando un miembro es constante, o alguna referencia no proporciona un constructor por defecto para este tipo de clase de tiempo, con el valor inicial de la clase de inicialización, no se le da el compilador, el programa en ejecución.
2. Cuando la inicialización de miembros de la clase const en el valor inicial utilizado cuando la clase de objeto no puede modificar su miembro const, diferentes objetos qué miembros const son iguales , no const diferencia const fuera de la clase de la clase.
3. Cuando el uso de una lista de inicialización de constructores para inicializar un método constante , la clase de objeto no puede modificar su método constante, pero un objeto diferente, cuyo método constante de valor puede ser diferente , de acuerdo con la clase de uso.