Directorio de artículos
Uno, clase y objeto
1. Paquete
2. Inicialización y limpieza de objetos
(5) Copia profunda y copia superficial
La copia profunda es una pregunta de entrevista clásica y un pozo común
- Copia superficial: si utiliza el constructor de copia proporcionado por el compilador, realizará una operación de copia superficial, que es una operación de copia de asignación simple
- Copia profunda: vuelva a solicitar espacio en el área del montón para la operación de copia
Si el atributo se desarrolla en el área del montón, debe proporcionar su propio constructor de copias para evitar problemas causados por copias superficiales
Ejemplo
#include<iostream>
using namespace std;
//深拷贝与浅拷贝
class person
{
public:
person()
{
cout << "person的默认构造函数调用" << endl;
}
person(int age, int height)
{
m_age = age;
m_height = new int(height);//用一个堆区指针来存放身高
cout << "person的有参构造函数调用" << endl;
}
//自己实现拷贝构造函数，解决浅拷贝带来的问题
person(const person &p)
{
cout << "person拷贝构造函数调用" << endl;
m_age = p.m_age;
//m_height = p.m_height; 编译器默认实现的代码
//深拷贝操作
m_height = new int(*p.m_height);
}
~person()//析构代码：将堆区开辟数据做释放操作
{
//堆区中的数据需程序员手动释放
if (m_height != NULL) //手动释放操作
{
delete m_height;
m_height = NULL;
}
cout << "person的析构函数调用" << endl;
}
int m_age;
int *m_height;
};
void test01()
{
person p1(18 ,160);
cout << "p1的年龄为：" << p1.m_age ;
cout << " p1的身高为：" << *p1.m_height << endl;
person p2(p1);
cout << "p2的年龄为：" << p2.m_age;
cout << " p2的身高为：" << *p2.m_height << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
(6) Lista de inicialización
Rol: C ++ proporciona una sintaxis de lista de inicialización para inicializar propiedades
gramática:构造函数 （ ）：属性1（值1），属性2（值2）......{ }
Ejemplo
#include<iostream>
using namespace std;
//初始化列表
class person
{
public:
//传统初始化操作
//person(int a, int b, int c)
//{
// m_A = a;
// m_B = b;
// m_C = c;
//}
//初始化列表初始化属性
person(int a, int b, int c) :m_A(a), m_B(b), m_C(c)
{
}
int m_A;
int m_B;
int m_C;
};
void test01()
{
//person p(1, 2, 3);
person p(30, 20, 10);
cout << "m_A = " << p.m_A << endl;
cout << "m_B = " << p.m_B << endl;
cout << "m_C = " << p.m_C << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
(7) Objetos de clase como miembros de la clase
Un miembro en C ++ puede ser un objeto de otra clase, llamamos a este miembro un miembro de objeto
Cuando se utilizan otros objetos de clase como miembros de esta clase, el objeto de clase se construye primero y luego él mismo
P.ej
class A {
}
class B
{
A a;
}
B类中有对象A作为成员，A为对象成员
Ejemplo
#include<iostream>
using namespace std;
#include<string>
//类对象作为类成员
//手机类
class phone
{
public:
phone(string pname)
{
m_Pname = pname;
cout << "phone的构造函数调用" << endl;
}
//手机品牌名
string m_Pname;
};
class person
{
public:
person(string name, string pname) :m_name(name), m_phone(pname)
{
cout << "person的构造函数调用" << endl;
}
string m_name; //姓名
phone m_phone;//手机品牌
};
void test01()
{
person p("张三", "三星");
cout << p.m_name << endl;
cout << p.m_phone.m_Pname << endl;
}
int main()
{
test01();
system("pause");
return 0;
}
Resultado de salida
(8) Miembros estáticos
Un miembro estático es agregar la palabra clave static antes de las variables miembro y funciones miembro, llamadas miembros estáticos
Los miembros estáticos se dividen en:
1 * variable miembro estática
- Todos los objetos comparten los mismos datos
- Asignar memoria durante la compilación
- Declaración en clase, inicialización fuera de clase
2 * función de miembro estático
- Todos los objetos comparten la misma función
- Las funciones miembro estáticas solo pueden acceder a variables miembro estáticas
Las funciones de miembros estáticos también tienen derechos de acceso: no se puede acceder a las funciones privadas de miembros estáticos fuera de la clase
Ejemplo
#include<iostream>
using namespace std;
#include<string>
//静态成员函数
class person
{
public:
static void func()
{
A = 20;
//B = 20;//静态成员函数不可访问非静态成员变量，无法区分是哪个对象的属性
cout << "static void func调用" << endl;
}
static int A;//静态成员变量
int B;//非静态变量成员
};
int person::A = 0;
//两种访问方式
void test01()
{
//1、通过对象访问
person p;
p.func();
//2、通过类名访问
person::func();
}
int main()
{
test01();
system("pause");
return 0;
}
3. Modelo de objetos de C ++ y este puntero
(1) almacenamiento separado de variables miembro y funciones miembro
En C ++, las variables miembro y las funciones miembro de una clase se almacenan por separado
Solo las variables miembro no estáticas pertenecen a los objetos de la clase
El compilador de C ++ asignará cada objeto vacíoEspacio de un byte, Es para distinguir la ubicación de la memoria ocupada por el objeto, cada objeto vacío debe tener una dirección de memoria única
- Variables miembro no estáticas: en objetos que pertenecen a la clase
- Variables miembro estáticas: en objetos que no pertenecen a la clase
- Función miembro no estática: en objetos que no pertenecen a la clase
- Función miembro estática: en objetos que no pertenecen a la clase
(2) El concepto de este puntero
La esencia de este puntero es una constante de puntero, el puntero no se puede modificar, pero el valor se puede modificar
Cada función miembro no estática solo producirá una instancia de función, lo que significa que varios objetos del mismo tipo compartirán un fragmento de código
C ++ resuelve los problemas anteriores proporcionando un puntero de objeto especial, este puntero
Este puntero apunta al objeto al que se llama la función miembro
- Este puntero es un puntero que implica cada función miembro no estática
- No es necesario definir este puntero, se puede utilizar directamente
El propósito de este puntero:
- Cuando el parámetro formal y la variable miembro tienen el mismo nombre, este puntero se puede usar para distinguir (resolver conflictos de nombres)
- Para devolver el objeto en sí en la función miembro no estática de la clase, puede usar return this ( use esto para devolver el objeto en sí )
Ejemplo
#include<iostream>
using namespace std;
class person
{
public:
person(int age)
{
//this 指针指向的是被调用的成员函数所属对象
this->age = age;
}
person& personAddage(person &p)
{
this->age += p.age;
//this指向p2的指针，而*this指向的就是p2这个对象本体
return *this;
}
int age;
};
//1、解决名称冲突
void test01()
{
person p1(18);
cout << "p1的年龄为：" << p1.age << endl;
}
//2、返回对象本身
void test02()
{
person p1(10);
person p2(10);
//链式编程思想
p2.personAddage(p1).personAddage(p1);
cout << "p2的年龄为：" << p2.age << endl;
}
int main()
{
test02();
system("pause");
return 0;
}
(3) Acceso de puntero nulo a funciones miembro
Los punteros nulos en C ++ también pueden llamar a funciones miembro, pero también prestan atención a si se usa este puntero
Si se utiliza este puntero, debe evaluarse para garantizar la solidez del código.
Ejemplo
#include<iostream>
using namespace std;
class person
{
public:
void showClassName()
{
cout << "this is person class" << endl;
}
void showPersonAge()
{
if (this == NULL)
return;
cout << "age = " << m_age << endl;
}
int m_age;
};
//1、解决名称冲突
void test01()
{
person *p = NULL;
p->showClassName();
p->showPersonAge();
}
int main()
{
test01();
system("pause");
return 0;
}
(4) función miembro modificada const
Función constante:
- Después de agregar const después de la función miembro, llamamos a esta función una función constante
- Las propiedades de los miembros no se pueden modificar en funciones constantes
- Después de agregar la palabra clave mutable en la declaración del atributo de miembro, aún se puede modificar en la función normal
Objeto regular:
- Agregue const antes de declarar el objeto para llamar al objeto un objeto constante
- Los objetos constantes solo pueden llamar a funciones constantes
Ejemplo
#include<iostream>
using namespace std;
class person
{
public:
//在成员函数后面加const，修饰的是this指向，让指针指向的值也不可修改
void showPerson()const
{
m_b = 100;//可修改
}
int m_age;
mutable int m_b;//特殊变量
};
void test01()
{
person p;
p.showPerson();
}
//常对象
//常对象只能调用常函数
void test02()
{
const person p;
//p.m_age = 100;
p.m_b = 100;
}
int main()
{
test01();
system("pause");
return 0;
}
[Nota] El curso de aprendizaje es-Tutorial de C ++ del Programa Dark Horse