Observe las diferencias y el significado de la copia profunda de C++ desde la clase de cadena
La copia profunda y la copia superficial están en la programación en C++. Para los objetos de clase, existen varios tipos de variables miembro en su interior y pueden ocurrir problemas durante el proceso de copia.
En el caso de los punteros, la copia superficial simplemente agrega un puntero a la memoria existente, mientras que la copia profunda agrega un puntero y solicita una nueva memoria, de modo que el puntero agregado apunte a la nueva memoria.
char * _ ptr
int _ countRef
Utilice _countRef para monitorear este espacio Cuando siempre haya un puntero que apunte a este espacio, no lo estará. liberado hasta que se alcance el recuento de referencia. Libérelo cuando sea 0, evitando así el problema que acaba de ocurrir. El código específico es el siguiente:
# include & ltiostream & gt
Usar espacio de nombres std
cadena de categoría
{
Público:
Cadena(const char* ptr = " ")
:_countRef(new int(1))
{
if (ptr == NULL)
{
_ptr = nuevo carácter;
* _ptr = '\ 0
}
Otro
{
_ ptr = nuevo char[strlen(ptr)+1];
strcpy(_ptr , ptr);
}
* _ count ref = 1;
}
Cadena (cadena constante y amperios)< / p>
:_ptr(s . ptr)
, _countRef(Francia _countRef)
{
++(* _ count ref );
}
~String()
{
Publicar();
}
Liberación no válida()
{
if ( - (*_countRef) == 0)
{
Eliminar[] _ ptr;
_ ptr = NULL
eliminar _ countRef
}
}
Cadena a cadena . operador=(cadena constante y amperios)
{
if (_ptr!= s._ptr)
{
Publicar () ; //Comprueba el objeto asignado y libera su propio puntero.
_ ptr = s. _ ptr
_ countRef = s. _ countRef
++(* _ recuento ref);
}
Devolver * this
}
Privado:
char * _ ptr
int * _ countRef
};
La copia en escritura tarda tiempo en abrir espacio en la memoria a medida que lo libera. Por lo tanto, cuando no necesitamos escribir, podemos crear objetos mediante copias superficiales sin abrir el espacio de la memoria, y solo abrir el espacio de la memoria cuando necesitemos escribir. Este método es copiar en escritura. Agregue copia en escritura al recuento de referencias original:
operador char[](int index)
{
{
-(* _ recuento ref);
_ recuento ref = new int(1);
char * ptr; = new char[strlen(_ ptr)+1];
strcpy(ptr, _ ptr);
_ ptr = ptr // Deja que el puntero apunte al espacio recién abierto .
}
return _ ptr[index];
}
La copia profunda consiste en abrir un nuevo espacio y dejar que lo nuevo space El contenido es exactamente el mismo que el contenido en el espacio original, y luego el puntero apunta a este espacio, de modo que el mismo espacio de memoria no se libere varias veces durante la deconstrucción.
# include & ltiostream & gt
# include & ltstring& gt
Cadena de categoría
{
Público :
Cadena (const char* pStr= " ")
{
if (pStr == NULL)
{
_pStr = nuevo carácter;
* _ pStr = ' \ 0
}
Otro
{
_ pStr = nuevo carácter[strlen(pStr)+1];
strcpy(_pStr, pStr);
}
}
Cadena (cadena constante y amperios)
:_ pStr(_ pStr = new char[strlen(s . _ pStr)+1])
{
strcpy(_pStr, s . _ pStr);
}
Cadena a cadena. operador = (cadena constante y amperios)
{
if (¡esto!= y amperios)
{
char * pTemp = nuevo char[strlen(s . _ pStr)+1];
strcpy(pTemp, s . _ pStr);
Eliminar []_ pStr;
_ pStr = pTemp
}
Return * this
}
~String() //Destructor
{
si (_pStr)
{
Eliminar[]_ pStr;
_ pStr = NULL
}
}
Privado:
char * _ pStr
};
void FunTest ()
{
cadena s 1 = " 1234 ";
Cadena S2
S2 = s 1;
Cadena S3(S2);
Cadena s4 = " asahsg
}
int main()
{
FunTest();
Sistema("pausa");
Devuelve 0;
}
Razonablemente Elegir la copia correcta ayudará a mejorar la eficiencia del código.