La cuarta semana de aprendizaje: sobrecarga de operadores y amigos y matrices de longitud variable

Seccion uno

1. Dar múltiples significados a los operadores existentes, de modo que el mismo operador pueda causar diferentes tipos de comportamientos para diferentes tipos de datos u operandos.
2. La esencia es la sobrecarga de funciones.
3. Puede sobrecargarse como funciones ordinarias y funciones miembro.
4. Convertir el operando del operador en el parámetro de la función del operador
5. Los operadores pueden sobrecargarse varias veces y llamarse según el tipo de parámetro real.

Sección dos

1. El operador de asignación está sobrecargado y solo se puede sobrecargar como función miembro
2. Función para asignar dos tipos diferentes de datos.
3. El operador de asignación es diferente del constructor de copia: uno ya está inicializado y el otro aún no está inicializado.

Copia superficial y copia profunda

1. Cuando los datos de la clase son char* str1, el constructor es nuevo una pieza de memoria nueva para str. Si es una copia poco profunda, la cadena de datos2 de la nueva clase también apunta al mismo espacio de memoria, y un espacio de memoria es señalado por dos punteros, lo que provocará varios problemas. (Por ejemplo, un puntero se elimina una vez y el otro puntero continúa eliminándose, lo que no funcionará)
2. Copia profunda, tienes que redefinirla tú mismo. Elimine el espacio original, cree uno nuevo y cópielo nuevamente. (No recuerde juzgar si es él mismo, juzgar la dirección. Evite cometer errores, porque s = s, pero si borra s, entonces s se pierde y no se puede asignar )
3. Devuelve la referencia del objeto de la clase, intenta mantener la naturaleza original.
4. El constructor de copia también se divide en copia superficial y profunda.

Amigos del tercer trimestre

1. La sobrecarga como función miembro no puede cumplir con los requisitos, pero la sobrecarga como función global no puede llamar a privado y luego sobrecargarse como amigo

class T
{
    
    
	private:
		char* ptr;
	public:
		T() 
		{
    
    
			ptr = new char[5];
			strcpy(ptr,"NONE");
		}
		T(char ch[])
		{
    
    
			ptr = new char[strlen(ch)+1];
			strcpy(ptr,ch);
		}
		T& operator=(const T& t)
		{
    
    
			if(this == &t)
				return *this;
			delete [] ptr;
			ptr = new char[strlen(t.ptr)+1];
			strcpy(ptr,t.ptr) ;
		 } 
		 ~T() {
    
    delete [] ptr;}
		 void show() {
    
    cout<<ptr<<endl;}
		 T& operator+=(const T& t)  
		 {
    
    
		 	int n=strlen(ptr);
		 	char ch[n];
		 	strcpy(ch,ptr);
		 	delete [] ptr;
		 	ptr = new char[strlen(t.ptr)+n+1];
		 	strcpy(ptr,ch);
		 	strcat(ptr,t.ptr);
		 	return *this;
		 }
};

int main()
{
    
    
	T t1,t2("Jeff");
	t1= t2;
	t1.show();
	t2.show();
	t1+=t2;
	t1.show();
}

Implementación de la clase de matriz de longitud variable de la cuarta sección

#include<iostream>
using namespace std;
class Array
{
    
    
	private:
		int* a;
		int size;
	public:
		Array():size(0)
		{
    
    
			a = new int[0];
			a = nullptr;
		}
		Array(const Array& b):size(b.size)
		{
    
    
			a = new int[size];
			memcpy(a,b.a,sizeof(int)*b.size);
		}
		~ Array()
		{
    
    
			if(a)
				delete [] a;
		}
		Array& operator=(const Array& b)
		{
    
    
			if(a == b.a)
				return *this;
			if(b.a==nullptr)
			{
    
    
				if(a)
					delete [] a;
				a =nullptr;
				size =0;
				return *this;
			}
			if(size<b.size)
			{
    
    
				if(a)
					delete [] a;
				a = new int[b.size];
			}
			memcpy(a,b.a,sizeof(int)*b.size);
			size = b.size;
			return *this;
		}
		void push_back(int n)
		{
    
    
			if(a)
			{
    
    
				int* temp = new int[size+1];
				memcpy(temp,a,sizeof(int)*(size)) ;
				delete [] a;
				a = temp;
				}
			else
			{
    
    
				a= new int[1];
			}
			a[size++] = n;
		}
		
		int length() {
    
    
			return size;
		}
		
		int& operator[](int i)
		{
    
    
			return a[i];
		}
};

int main()
{
    
    
	Array a1;
	for(int i=0;i<5;i++)
		a1.push_back(i);
	Array b,c;
	b=a1;
	for(int i=0;i<a1.length();i++)
		cout<<b[i]<<" ";
	b=c;
	for(int i=0;i<b.length();i++)
		cout<<b[i]<<" ";
	cout<<endl;
	a1[3]=100;
	Array d(a1);
	for(int i=0;i<d.length();i++)
		cout<<d[i]<<" ";
	return 0;
}

1. memcpy(目标ptr,复制ptr,sizeof(int)* size)Hacer copia de matriz