1. Clase C ++
-
La composición de la clase
Consiste en métodos y datos. El método puede ser público o privado, y los datos son generalmente privados.
Class Human{
public:
void eat();
void drink();
void play();
void sleep();
private:
void seeSister();
string name;
int age;
}
2. Constructor
-
Clasificación de constructores
Constructor predeterminado Constructor
personalizado Constructor de
copias Constructor de
asignaciones
① Constructor predeterminado
Al crear un objeto, el compilador genera automáticamente un constructor predeterminado, que es el constructor sintético predeterminado.
clase:
Class Human{
public:
Human(); //默认构造函数
private:
string name;
int age;
}
Human h; //创建对象，编译器调用Human()合成的默认构造函数
Cuando los datos de la variable se inicializan en el constructor, es el constructor predeterminado definido manualmente.
clase:
Class Human{
public:
Human(); //默认构造函数
private:
string name;
int age;
}
lograr:
Human::Human(){
name = "张三";
age = 18;
}
transferir:
Human h; //创建对象，编译器调用Human()手动定义的默认构造函数
② Constructor personalizado
Agregue parámetros al constructor e inicialice los datos.
clase:
Class Human{
public:
Human(string name,int age); //自定义构造函数
private:
string name;
int age;
}
lograr:
Human::Human(string name,int age){
this->name = name;
this->age = age;
}
transferir:
Human h("李四",22); //创建对象，编译器调用自定义的构造函数
③ Constructor de copia
Cuando se crea un objeto, se inicializa y se asigna otro objeto al objeto creado actualmente, se llama al constructor de copia.
clase:
Class Human{
public:
Human(const Human&); //拷贝构造函数Human(const Human& other) other可以省略
private:
string name;
int age;
}
lograr:
Human::Human(const Human& other){
name = other.name;
age = other.age;
}
transferir:
Human h1("王五",21); //创建对象，编译器调用自定义的构造函数
Human h2(h1); //调用拷贝构造函数
Human h3 = h1; //调用拷贝构造函数
La función de copia anterior es un constructor de copia definido manualmente.Cuando se omite el constructor de copia, el compilador generará y llamará automáticamente al constructor de copia, que es un constructor de copia sintético.
El escenario de uso del constructor de copias:
cuando el parámetro real de la función es un objeto, el tipo de retorno es una clase.
Objeto de matriz, inicializado.
Human test(Human human){
return human;
}
Human test1(Human& human){
return human;
}
Human h1,h2,h3;
test(h1); //调用两次拷贝函数
test1(h1); //调用一次拷贝函数
Human men[] = {
h1,h2,h3}; //调用三次拷贝函数
④ Constructor de asignación
Cuando se crea un objeto, cuando se asigna otro objeto al objeto creado actualmente, se llama al constructor de asignación de copia.
clase:
Class Human{
public:
Human& operator=(const Human&); //赋值构造函数
private:
string name;
int age;
}
lograr:
Human& Human::operator=(const Human& other){
name = other.name;
age = other.age;
}
transferir:
Human test(Human& human){
return human;
}
Human h1("王五",21); //创建对象，编译器调用自定义的构造函数
Human h2(h1); //调用拷贝构造函数
h2 = h1; //调用赋值构造函数
Human h3;
h3 = test(h1); //调用赋值构造函数
3. Destructor
Generalmente se usa para liberar recursos (por ejemplo, cuando se solicita memoria dinámica y necesita ser liberada) Cuando no hay recursos para liberar y no se escribe ningún destructor, el compilador lo llamará automáticamente cuando el objeto sea destruido.
clase:
Class Human{
public:
~Human(); //析构函数
}
4. Miembros de datos estáticos y funciones de miembros estáticos
-Miembros de datos estáticos
definición:
Class Human{
public:
void play();
private:
static string name; //静态数据成员
}
inicialización:
string Human::name = "张三"; //初始化静态数据成员
void play(){
return name; //类的方法中可以直接读写静态数据成员
}
-Función de miembro estático
Se puede acceder a las funciones miembro estáticas directamente usando el nombre de la clase, o se puede acceder a ellas después de que se crea el objeto.
Las funciones de miembros estáticos no pueden acceder a miembros de datos ordinarios (miembros de instancia) y métodos de miembros ordinarios (métodos de instancia).
definición:
Class Human{
public:
void play();
static void drink();
private:
static string name; //静态数据成员
int age;
}
lograr:
Human::drink(){
return name; //只能访问静态数据成员和静态成员方法
}
transferir:
Human::drink(); //可以直接用类型调用
Human h1;
h1.drink(); //对象也可以调用
5. miembros de datos const y funciones de miembro const
miembro de datos const
Los miembros de datos de tipo const no se pueden modificar y solo se pueden leer.
definición:
Class Human{
public:
void play();
private:
static string name; //静态数据成员
int age;
const string boolType; //const数据成员
// const string boolType = "A"; //类内初始化
}
Inicialización: puede usar el valor de la clase, también puede usar la lista de inicialización del constructor
Human::Hunman():boolType("未知"){
return name;
}
función miembro constante
En esta función, no se pueden modificar miembros de datos, solo leer. Tampoco puede llamar a otras funciones miembro que no sean constantes
definición:
Class Human{
public:
void play() const;
void setName();
private:
static string name; //静态数据成员
int age;
}
Inicialización: puede usar el valor de la clase, también puede usar la lista de inicialización del constructor
void Human::play() const{
return name; //只能读，不能修改
setName(); //不能调用其他的非const的方法
}
5. Combinación y agregación
combinación
[Ejemplo] Una categoría de computadora se compone de chips de CPU, discos duros, memoria, etc.
Entre ellos, el chip de CPU también está representado por una clase, y la clase de CPU y la clase de computadora están en una relación combinada. Cuando se crea un objeto de computadora, también se creará el objeto de CPU, y cuando se destruye el objeto de computadora, también se destruirá el objeto de CPU.
Categoría de CPU:
Class CPU{
public:
CPU(const string *name,const int version);
private:
string name;
int version;
}
Categoría de computadora:
#include "CPU.h" //包含CPU类
Class Computer{
public:
Computer(const string *name,const int version,
int hardDisk,int memory);
private:
CPU cpu;
int hardDisk;
int memory;
}
inicialización:
Computer::Computer(const string *name,const int version,
int hardDisk,int memory):cpu(name,version){
this->hardDisk = hardDisk;
this->memort = memory;
}
polimerización
[Ejemplo] Una computadora necesita una tarjeta de sonido externa, cree una clase de tarjeta de sonido.
La clase de tarjeta de sonido y la clase de computadora están en una relación agregada. Cuando se crea un objeto de computadora, también se creará el objeto de la tarjeta de sonido, y cuando se destruye el objeto de la computadora, el objeto de la tarjeta de sonido no se destruirá.
Categoría de computadora:
class Voice; //直接定义Voice类
Class Computer{
public:
void addVoice(Voice *voice); //添加声卡
private:
CPU cpu;
int hardDisk;
int memory;
}
inicialización:
void Computer::addVoice(Voice *voice){
this->voice = voice;
}
transferir:
#include "Computer.h" //包含计算机类
#include "Voice.h" //包含声卡类
Computer cmp;
cmp.addVoice(); //调用添加声卡的方法