[C++] Clases y Objetos (Parte 2)

Función miembro predeterminada de una clase

Si una clase no tiene miembros, se denomina clase vacía. ¿Nada en la clase vacía? No, cualquier clase generará automáticamente las siguientes 6 funciones miembro predeterminadas si no las escribimos.

Constructor

El constructor es una función miembro especial con el mismo nombre que el nombre de la clase . El compilador lo llama automáticamente cuando se crea un objeto de un tipo de clase, lo que garantiza que cada miembro de datos tenga un valor inicial apropiado y se llame solo una vez durante el ciclo de vida del objeto.

La tarea principal del constructor no es crear un objeto, sino inicializar el objeto.

rasgo:

1. El nombre de la función es el mismo que el nombre de la clase.
2. Sin valor de retorno.
3. El compilador llama automáticamente al constructor correspondiente cuando se crea una instancia del objeto.
4. Los constructores pueden estar sobrecargados.

Ejemplo de código:

class Date
{
    
    
public :
	// 1.无参构造函数
	Date ()
	{
    
    }
	// 2.带参构造函数
	Date (int year, int month , int day )
	{
    
    
		_year = year ;
		_month = month ;
		_day = day ;
	}
private :
	int _year ;
	int _month ;
	int _day ;
};
void TestDate()
{
    
    
	Date d1; // 调用无参构造函数
	Date d2 (2015, 1, 1); // 调用带参的构造函数
	// 注意：如果通过无参构造函数创建对象时，对象后面不用跟括号，否则就成了函数声明
	// 以下代码的函数：声明了d3函数，该函数无参，返回一个日期类型的对象
	Date d3();
}

Si no hay un constructor definido explícitamente en la clase, el compilador de C++ generará automáticamente un constructor predeterminado sin argumentos y, una vez que el usuario lo defina explícitamente, el compilador ya no lo generará.

Ejemplo de código:

class Date
{
    
    
public:
	/*
	// 如果用户显式定义了构造函数，编译器将不再生成
	Date (int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	*/
private:
	int _year;
	int _month;
	int _day;
};

void Test()
{
    
    
	// 没有定义构造函数，对象也可以创建成功，因此此处调用的是编译器生成的默认构造函数
	Date d;
}

Tanto el constructor sin parámetros como el constructor predeterminado se denominan constructores predeterminados y solo puede haber un constructor predeterminado.
Nota: Los constructores sin argumentos, los constructores predeterminados completos y los constructores generados de forma predeterminada por el compilador pueden considerarse funciones miembro predeterminadas.

Ejemplo de código:

// 默认构造函数
class Date
{
    
    
public:
	Date()
	{
    
    
		_year = 1900 ;
		_month = 1 ;
		_day = 1;
	}
	Date (int year = 1900, int month = 1, int day = 1)
	{
    
    
		_year = year;
		_month = month;
		_day = day;
	}
private :
	int _year ;
	int _month ;
	int _day ;
};
// 以下测试函数能通过编译吗？
void Test()
{
    
    
	Date d1;
}

C++ divide los tipos en tipos integrados (tipos primitivos) y tipos personalizados. El tipo incorporado es el tipo que ha sido definido por la gramática: como int/char..., el tipo personalizado es el tipo que definimos usando class/struct/union.Si observa el siguiente programa, encontrará que el compilador genera un constructor predeterminado que será su función de miembro predeterminada llamada por el miembro de tipo personalizado _t.

class Time
{
    
    
public:
	Time()
	{
    
    
		cout << "Time()" << endl;
		_hour = 0;
		_minute = 0;
		_second = 0;
	}
private:
	int _hour;
	int _minute;
	int _second;
};
class Date
{
    
    
private:
	// 基本类型(内置类型)
	int _year;
	int _month;
	int _day;
	// 自定义类型
	Time _t;
};
int main()
{
    
    
	Date d;
	return 0;
}

incinerador de basuras

Destructor: contrario a la función del constructor, el destructor no completa la destrucción del objeto, y el compilador realiza la destrucción del objeto local. Cuando se destruye el objeto, se llamará automáticamente al destructor para completar algún trabajo de limpieza de recursos de la clase.

rasgo:

1. El nombre del destructor está precedido por el carácter ~ antes del nombre de la clase.
2. Sin parámetros, sin valor de retorno.
3. Una clase tiene uno y sólo un destructor. Si no se define explícitamente, el sistema generará automáticamente un destructor predeterminado.
4. Cuando finaliza el ciclo de vida del objeto, el sistema de compilación de C++ llama automáticamente al destructor.

Ejemplo de código:

typedef int DataType;
class SeqList
{
    
    
public :
	SeqList (int capacity = 10)
	{
    
    
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
    
    
		if (_pData)
		{
    
    
			free(_pData ); // 释放堆上的空间
			_pData = NULL; // 将指针置为空
			_capacity = 0;
			_size = 0;
		}
	}
private :
	int* _pData ;
	size_t _size;
	size_t _capacity;
};

Destructor predeterminado generado por el compilador que llama a su destructor para miembros de un tipo personalizado.

Ejemplo de código:

class String
{
    
    
public:
	String(const char* str = "jack")
	{
    
    
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
    
    
		cout << "~String()" << endl;
		free(_str);
	}
private:
	char* _str;
};

class Person
{
    
    
private:
	String _name;
	int _age;
};

int main()
{
    
    
	Person p;
	return 0;
}

copiar constructor

Constructor: solo hay un único parámetro formal, que es una referencia a un objeto de este tipo de clase (generalmente modificado const), que el compilador llama automáticamente cuando se crea un nuevo objeto con un objeto de tipo de clase existente.

rasgo:

1. El constructor de copias es una forma sobrecargada del constructor.
2. El constructor de copias tiene solo un parámetro y debe pasarse por referencia. El uso del método de paso por valor provocará infinitas llamadas recursivas.
3. Si no se muestra ninguna definición, el sistema genera un constructor de copia predeterminado. El objeto constructor de copia predeterminado se copia en orden de bytes de acuerdo con el almacenamiento de memoria.Esta copia se denomina copia superficial o copia de valor.

sobrecarga del operador de asignación

De forma predeterminada, los operadores se utilizan para las variables de tipo integradas. Si una variable de un tipo definido por el usuario desea utilizar estos operadores, debe sobrecargarlos usted mismo.
La sobrecarga de operadores significa que tenemos que escribir una definición de función para implementar el comportamiento de este operador.

C++ introduce la sobrecarga de operadores para mejorar la legibilidad del código. La sobrecarga de operadores es una función con un nombre de función especial, así como su tipo de valor de retorno, nombre de función y lista de parámetros. Su tipo de valor de retorno y lista de parámetros son similares a las funciones ordinarias.

El nombre de la función es: la palabra clave operator seguida del símbolo del operador que debe sobrecargarse.
Prototipo de función: Operador de tipo de valor de retorno (lista de parámetros).

Nota:
1. No se puede crear un nuevo operador concatenando otros símbolos: como operator@
2. Un operador sobrecargado debe tener un operando de un tipo de clase o un tipo de enumeración
3. El significado de un operador para un tipo incorporado no puede ser Cambiar, por ejemplo: el entero incorporado +, no puede cambiar su significado
4. Cuando una función sobrecargada es un miembro de clase, sus parámetros formales parecen ser uno menos que el número de operandos.El operador de la función miembro tiene un parámetro predeterminado this, que está limitado a El primer parámetro formal
5. .* , :: , sizeof , ?: , .Tenga en cuenta que los 5 operadores anteriores no se pueden sobrecargar.

Sobrecarga del operador de asignación:

1. Tipo de parámetro
2. valor de retorno
3. Comprueba si te asignas un valor
4. devolver *esto
5. Si una clase no define explícitamente una sobrecarga del operador de asignación, el compilador también generará uno para completar la copia del valor endian del objeto.

función miembro de clase modificada const

Una función miembro de clase modificada por const se denomina función miembro const, y una función miembro de clase modificada por const en realidad modifica el puntero implícito this de la función miembro, lo que indica que ningún miembro de la clase se puede modificar en la función miembro.

1. ¿Puede un objeto const llamar a una función miembro no const? no poder
2. ¿Pueden los objetos no constantes llamar funciones miembro constantes? puede

Sobrecarga del operador Take address y const take address

Estas dos funciones miembro predeterminadas generalmente no necesitan ser redefinidas y el compilador las generará de manera predeterminada.

class Date
{
    
    
public :
	Date* operator&()
	{
    
    
		return this ;
	}
	const Date* operator&()const
	{
    
    
		return this ;
	}
private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};

Estos dos operadores generalmente no necesitan sobrecargarse. Puede usar la sobrecarga de la dirección predeterminada generada por el compilador. ¡Solo en casos especiales, necesita sobrecargar, como permitir que otros obtengan el contenido especificado!