Conceptos básicos de C (2)

2024-07-12

Tabla de contenido

1. Clases y Objetos

1.1 Definición de clase

1.2 Calificadores de acceso

1.3 Dominio de clase

2. Creación de instancias

2.1 Concepto de instanciación

2.2 Tamaño del objeto

3.este puntero

4.Funciones miembro predeterminadas de las clases.

4.1Constructor

4.2 Destructor

4.5 Sobrecarga del operador

1. Clases y Objetos

1.1 Definición de clase

Formato de definición de clase

clase es la palabra clave que define la clase, Pila es el nombre de la clase y {} es el cuerpo de la clase. Tenga en cuenta que el punto y coma al final de la definición no se omite. Los contenidos del cuerpo de la clase se denominan miembros de la clase: las variables de la clase se denominan atributos o las variables miembro de la clase las funciones de la clase se denominan métodos o funciones miembro de la clase.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	//成员变量
	int* a;
	int top;
	int  capacity;
	//成员函数
	void Push()
	{
 
	}
	void Pop()
	{
 
	}
};//分号不能省略
int main()
{
	
 
	return 0;
}

Para distinguir las variables miembro, generalmente se acostumbra agregar un identificador especial a la variable miembro, como comenzar con _ o m_ antes o después de la variable miembro.No existen regulaciones sobre esta sintaxis de C++, es solo una cuestión de preferencia personal o de la empresa.


//为区分成员变量，一般前面加_
//成员变量
int* _a;
int _top;
int  _capacity;

Struct en C++ también puede definir clases. C++ es compatible con el uso de struct en C. Al mismo tiempo, struct se ha actualizado a una clase. El cambio obvio es que las funciones también se pueden definir en struct. Todavía recomiendo usar class para definir clases.

Los miembros definidos en una clase están predeterminados en línea

1.2 Calificadores de acceso

C ++ es una forma de implementar la encapsulación: utiliza clases para combinar las propiedades y métodos de un objeto para hacerlo más completo y proporciona selectivamente su interfaz a usuarios externos a través de derechos de acceso.

Se puede acceder directamente a los miembros modificados por público (público) fuera de la clase, no se puede acceder directamente a los miembros modificados por protegido (protegido) y privado (privado) fuera de la clase, protegido y privado son lo mismo
El alcance del permiso de acceso comienza desde la posición donde aparece el permiso de acceso hasta que aparece el siguiente calificador de acceso. Si no hay un calificador de acceso posterior, el alcance termina en }, que es el final de la clase.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
	
	///
 
	void Push()
	{
 
	}
	//Push 没给限定符 class默认私有 private 
	///
public:
	void Pop()
	{
 
	}
	int Swap()
	{
 
	}
	//Pop和Swap 被public修饰，直到下一个限定符出现之前都为公有
	///
protected:
	int add();
//add 被public修饰，直到下一个限定符出现之前都为保护
/// /
 
private:
 
	int* _a;
	int _top;
	int  _capacity;
//成员变量被private修饰，直到}结束都为私有
};
int main()
{
	Stack st;
	//公有可以访问
	st.Pop();
	st.Swap();
	//私有不可访问
	st._top;
 
 
 
	return 0;
}

Notas adicionales:

Cuando los calificadores de acceso no modifican los miembros de la definición de clase, su valor predeterminado es privado y el valor predeterminado de estructura es público.
Generalmente, las variables miembro estarán restringidas a privadas/protegidas, y las funciones miembro que otros deben utilizar se colocarán como públicas.

1.3 Dominio de clase

La clase define un nuevo ámbito. Todos los miembros de la clase están en el ámbito de la clase. Al definir miembros fuera de la clase, debe utilizar el operador ::scope para indicar a qué ámbito de clase pertenece el miembro.

El dominio de clase afecta las reglas de búsqueda de compilación. Si Init en el siguiente programa no especifica la pila de dominio de clase, el compilador tratará a Init como una función global. Si no puede encontrar miembros como _top durante la compilación, irá al. dominio de clase para encontrarlos.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
public:
	void Init(int x, int y);
 
};
void Stack::Init(int x, int y)
 
	{
		 _top = x;
		 _capacity = y;
	}
int main()
{
	
	return 0;
}

Aviso:

Las declaraciones y definiciones de funciones en la clase se separan. Una vez creada la clase, se forma un nuevo dominio de clase. Es necesario especificar el dominio de clase; de lo contrario, será inaccesible.

2. Creación de instancias

2.1 Concepto de instanciación

El proceso de crear un tipo en la memoria física se llama creación de instancias de clase.
Una clase es una descripción abstracta de un objeto. Es algo así como un modelo. Limita las variables miembro de la clase. Estas variables miembro solo se declaran y no se asigna espacio cuando se crea una instancia de un objeto.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
//声明
 
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	Stack::_top = 2024;
	//编译器报错，_top只是声明，并未实例化
 
	return 0;
}

Una clase puede crear instancias de múltiples objetos, y los objetos instanciados ocupan espacio físico real y almacenan variables miembro. Por ejemplo: crear instancias de objetos de una clase es como usar dibujos de diseño arquitectónico para construir una casa en la realidad. Las clases son como dibujos de diseño. Los dibujos de diseño planifican el número de habitaciones, el tamaño de la casa, etc., pero no hay elementos físicos. edificio, y no puede vivir en la gente, sólo cuando una casa se construye usando los dibujos de diseño la gente puede vivir en la casa.La misma clase es como un dibujo de diseño. Simplemente le dice al compilador cuánta memoria se va a abrir, pero no abre la memoria. Solo a los objetos instanciados se les asigna memoria física para almacenar datos.


//text.cpp
#include<iostream>
using namespace std;
 
class Stack
{
 
 
//声明
	int* _a;
	int _top;
	int  _capacity;
 
};
 
int main()
{
	
	
	Stack st;
    st._top=2024;
//Stack实例化出st，系统已经给st分配内存了，可以存储数据，编译通过
 
	return 0;
}

2.2 Tamaño del objeto

¿Analizar qué miembros tiene el objeto de clase? Cada objeto instanciado por una clase tiene un espacio de datos independiente, por lo que el objeto debe contener variables miembro. Entonces, ¿se incluyen las funciones miembro? Primero, una vez compilada la función, es una sección de instrucciones que no se puede almacenar en el objeto. Estas instrucciones se almacenan en un área separada (segmento de código). Si el objeto debe almacenarse, solo puede ser un puntero. una función miembro. ¿Es necesario almacenar punteros en el objeto? La fecha crea una instancia de dos objetos d1 y d2. Tanto di como d2 tienen variables miembro independientes _año/_mes/_día para almacenar sus propios datos, pero las funciones miembro Init de d1 y d2 son el puntero /Imprimir. es el mismo y se desperdicia si se almacena en el objeto. Si usa Date para crear instancias de 100 objetos, entonces el puntero de la función miembro se almacenará repetidamente 100 veces, lo cual es un desperdicio. De hecho, no es necesario almacenar el puntero de función. El puntero de función es una dirección. La función de llamada se compila en una instrucción de ensamblaje [dirección de llamada]. No se encuentra en tiempo de ejecución. Solo se puede encontrar dinámicamente. El estado se encuentra en tiempo de ejecución, por lo que es necesario almacenar la dirección de la función.

Reglas de alineación de la memoria

El primer miembro está en la dirección desplazada 0 de la estructura.
Otras variables miembro deben estar alineadas en direcciones que sean múltiplos del número de alineación.
Número de alineación = El menor entre el número de alineación predeterminado del compilador y el tamaño del miembro
El número de alineación predeterminado de la plataforma VS x64 es 4 y el número de alineación predeterminado de x86 es 8
El tamaño total de la estructura es: un múltiplo entero del número de alineación máximo (la mayor de todas las variables de tipo y el número de alineación predeterminado más pequeño)
Si las estructuras están anidadas, la estructura anidada se alinea con un múltiplo entero de su propio número de alineación máximo, y el tamaño total de la estructura es un múltiplo entero de todos los números de alineación máximos (incluido el número de alineación de las estructuras anidadas)


class A
{
public:
	void Print()
	{
		cout << _ch << endl;
	}
private:
	char _ch;
 
	int _i;
};
//_ch 是一个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存在_ch
// _i是4个字节，默认对齐数是4，最大对齐数是4，所以开辟4个字节用来存储_i
class B
{
public:
	void Print()
	{
	//。。。
	}
 
	
};
class B
{
 
 
};
//B和C里面没有存储任何成员变量，只有一个函数，可成员函数不存对象里面
// 按理来说是0，但是结构体怎么会没大小，为表示对象存在C++对这种规定大小为1，为了占位标识对象存在

3.este puntero

Después de que el compilador compila, las funciones miembro de la clase agregarán un puntero a la clase actual en la primera posición del parámetro formal de forma predeterminada, llamado este puntero.

Por ejemplo, el prototipo de Init en la clase Date es void Init (Fecha * const this, int año, int mes, int día). Al acceder a variables miembro en las funciones miembro de la clase, se accede a la esencia a través de este puntero. como _año en la función Iniciar, este->_año=año.

prototipo:


class Date
{
	void Print()
	{
 
		cout << _year << "n" << _month << "n" << _day << endl;
	}
	void Init( int year, int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
 
	}
	
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(2024,7,10);
 
d1.Print();
Date d2;
 
d2.Init(2024, 7, 9);
d2.Print();

prototipo real


class Date
{
	void Init(Date* const this,int year, int month,int day)
	
	{
		this->_year = year;
		this->_month = month;
		this->_day = day;
 
	}
	void Printf(Date* const this)
	
	{
 
		cout << this->_year << "n" <<this-> _month << "n" << this->_day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
 
};


Date d1;
d1.Init(&d1,2024,7,10);
d1.Print(&d1);
 
Date d2;
d2.Init(&d2,2024, 7, 9);
d2.Print();

C ++ estipula que no está permitido escribir este puntero en la posición de los parámetros reales y los parámetros formales (el compilador lo manejará al compilar), pero este puntero se puede usar explícitamente en el cuerpo de la función. Este puntero no se puede modificar, pero el. El contenido al que apunta este puntero puede

este puntero se almacena en la pila

4.Funciones miembro predeterminadas de las clases.

La función miembro predeterminada es una función miembro que el usuario no define explícitamente y el compilador la genera automáticamente. Se denomina función miembro predeterminada.

4.1Constructor

El constructor es una función miembro especial. Cabe señalar que aunque el constructor se llama constructor, el contenido principal del constructor no es abrir espacio para crear objetos (el objeto local que usualmente usamos es el espacio que se abre cuando se abre). se crea el marco de pila)), pero el objeto se inicializa cuando se crea una instancia del objeto. La esencia del constructor es reemplazar la función Init que escribimos antes en las clases Stack y Date. La llamada automática del constructor reemplaza perfectamente la función Init.

Características del constructor:

El nombre de la función es el mismo que el nombre de la clase.
Sin valor de retorno (no es necesario que proporciones nada como valor de retorno y no escribas void. Esta es la regla de C++)
Cuando se crea una instancia del objeto, el sistema llamará automáticamente al constructor correspondiente.
Los constructores pueden estar sobrecargados.
Si no hay un constructor explícito definido en la clase, el compilador de C++ generará automáticamente un constructor predeterminado sin parámetros. Una vez que el usuario define explícitamente el constructor, el compilador ya no lo generará.


class Date
{public:
	//1.无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//2.带参构造函数
	Date(int year, int month, int day)
{
		_year = year;
		_month = month;
		_day = day;
	}
 
 
	//3.全缺省构造函数
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
private:
	int _year;
	int _month;
	int _day;
 
};

El constructor sin parámetros, el constructor predeterminado y el constructor generado por el compilador de forma predeterminada cuando no escribimos un constructor se denominan constructores predeterminados. Pero sólo uno de estos tres puede existir, no al mismo tiempo. Aunque el constructor sin parámetros y el constructor predeterminado completo constituyen una sobrecarga de funciones, habrá ambigüedad al llamarlos.Tenga en cuenta que no solo el constructor predeterminado es el que genera el compilador de forma predeterminada, sino que es el constructor, el constructor sin parámetros, y el constructor predeterminado completo también es el constructor predeterminado. En resumen, se puede llamar sin pasar parámetros.

No lo escribimos. La construcción generada por el compilador de forma predeterminada no tiene requisitos para la inicialización de variables miembro de tipo integradas, es decir, si se inicializa o no, depende del compilador.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
	}
 
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
//两个Stack实现队列
class MyQueue
{
private:
    int size;
	Stack pushst;
	Stack popst;
};
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

C++ divide los tipos en tipos personalizados y tipos integrados (tipos básicos). Los tipos integrados son los tipos de datos nativos proporcionados por el lenguaje, como int/char/double/pointer, etc. Los tipos personalizados son tipos que definimos nosotros mismos usando palabras clave como class/struct.El constructor aquí se inicializa automáticamente y VS también inicializa el tamaño de tipo incorporado. Los diferentes compiladores tienen diferentes valores de inicialización y C ++ no los especifica.

Para variables miembro de tipo personalizado, es necesario llamar al constructor predeterminado de esta variable miembro para inicializarla.Si esta variable miembro no tiene un constructor predeterminado, se informará un error. Si queremos inicializar esta variable miembro, necesitamos usar una lista de inicialización para resolverlo.

Resumen: en la mayoría de los casos, necesitamos implementar el constructor nosotros mismos. En algunos casos, es similar a MyQueue y cuando Stack tiene un constructor predeterminado, MyQueue se puede generar y usar automáticamente.

4.2 Destructor


~Stack()
{
	free(_a);
	_a = nullptr;
	_top = _capacity = 0;
}

Características del destructor:

1. El nombre del destructor está precedido de caracteres ~

2. Sin parámetros ni valor de retorno (consistente con el constructor)

3. Una clase sólo puede tener un destructor.Si no se muestra la definición, el sistema generará automáticamente un destructor predeterminado.

4. Cuando finalice el ciclo de declaración de objetos, el sistema llamará automáticamente al destructor.

5. Al igual que el constructor, no escribimos el destructor generado automáticamente por el compilador y no procesamos los miembros de tipo integrados. Los miembros de tipo personalizado llamarán a otros destructores.

6. También debe tenerse en cuenta que cuando mostramos el destructor, también se llamará al destructor del miembro de tipo personalizado, lo que significa que el destructor del miembro de tipo personalizado se llamará automáticamente sin importar la situación.


//text.cpp
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请失败");
		}
		_capacity = n;
		_top = 0;
 
 
	}
 
	~Stack()
	{
		free(_a);
		_a = nullptr;
		_top=_capacity=0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
	
};
//两个Stack实现队列
class MyQueue
{public:
    //编译器默认生成MyQueue的构造函数调用了Stack的构造，完成了两个成员的初始化
	//编译器默认生成MyQueue的析构函数调用了Stack的析构，释放了Stack内部的资源
	//显示写析构也会调用Stack的析构
	~MyQueue()
	{
		cout << "~MyQueue" << endl;
	}
private: 
	
	Stack pushst;
	Stack popst;
	
};
 
 
int main()
{
 
	MyQueue my;
 
 
	return 0;
}

El destructor en MyQueue no hace nada, pero C ++ estipula que se llamará a otros destructores para liberar la memoria.

Si no se solicitan recursos, no es necesario escribir el destructor y el destructor predeterminado generado por el compilador se puede usar directamente, como Fecha. Si se puede usar el destructor predeterminado generado, no es necesario escribir explícitamente el destructor. como MyQueue, pero hay una aplicación de recursos al destruir, asegúrese de escribir el destructor directamente, de lo contrario provocará una pérdida de recursos como Stack.

4.5 Sobrecarga del operador

Cuando se utilizan operadores en objetos escritos, el lenguaje C++ nos permite especificar nuevos significados en forma de sobrecarga de operadores. C ++ estipula que cuando un objeto de tipo de clase usa un operador, debe convertirse en una llamada al operador correspondiente. De lo contrario, el compilador informará un error.
La sobrecarga de operadores es una función con un nombre específico. Su nombre se compone de operador y el operador que se definirá más adelante.Al igual que otras funciones, también tiene su tipo de retorno y lista de parámetros, así como un cuerpo de función.


 
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}

Una función de operador sobrecargada toma tantos parámetros como parámetros sobre los que actúa el operador.La comodidad de transporte unario tiene un parámetro y el operador binario tiene dos parámetros. El operando izquierdo del operador binario se pasa al primer parámetro y el operando derecho se pasa al segundo parámetro.


//text.cpp
#include<iostream>
using namespace std;
 
class Date
{
public:
	Date(int year, int month, int day)
	{
	_year= year;
		_month = month;
		_day = day;
 
	}
 
 
 
	int _year;
	int _month;
	int _day;
 
};
 
bool operator<(Date d1, Date d2)
{
 
}
bool operator==(Date d1,Date d2)
{
	return d1._year == d2._year && d1._month == d2._month && d1._day == d2._day;
}
int main()
{
 
	Date d1(2024, 7, 10);
	Date d2(2024,7,9);
//两种用法都可以
	d1 == d2;
	operator==(d1 , d2);
	return 0;
}

Si una función de operador sobrecargada es una función miembro, su primer operando se pasa al puntero this implícito de forma predeterminada. Por lo tanto, cuando el operador está sobrecargado como función miembro, tiene un parámetro menos que el operando.
Después de sobrecargar un operador, su precedencia y asociatividad siguen siendo consistentes con las operaciones de tipo integradas.
No se puede crear un operador sexual concatenando coincidencias que no existen en la sintaxis: por ejemplo operador@.

Compartir tecnología