- Os produtos eletrônicos que compramos em nossas vidas basicamente têm configurações de fábrica, e algumas de nossas próprias informações e dados serão excluídos quando não os usarmos em um determinado dia para garantir a segurança.
-
Orientado a objetos em C ++ vem da vida, e cada objeto também terá configurações iniciais e configurações para limpar os dados antes que o objeto seja destruído.
1. Construtor e destruidor
A inicialização e limpeza de objetos também são duas questões de segurança muito importantes
Um objeto ou variável não tem estado inicial, e as consequências de seu uso são desconhecidas
Da mesma forma, depois de usar um objeto ou variável, se não for limpo a tempo, também causará alguns problemas de segurança
C ++ usa o construtor e o destruidor para resolver os problemas acima, essas duas funções serão chamadas automaticamente pelo compilador para completar o trabalho de inicialização e limpeza do objeto.
A inicialização e limpeza de objetos é o que o compilador nos força a fazer, portanto, se não fornecermos construção e destruição, o compilador fornecerá
O construtor e o destruidor fornecidos pelo compilador são implementações vazias.
-
Construtor: A função principal é atribuir valores às propriedades do membro do objeto quando o objeto é criado.O construtor é automaticamente chamado pelo compilador e não precisa ser chamado manualmente.
-
Destruidor: A função principal é chamar automaticamente o sistema antes que o objeto seja destruído para realizar algum trabalho de limpeza.
A ordem de execução do destruidor é estritamente oposta à do construtor
Sintaxe do construtor:类名(){}
-
Construtor, sem valor de retorno e sem escrever void
-
O nome da função é igual ao nome da classe
-
O construtor pode ter parâmetros, então pode ocorrer sobrecarga
-
O programa irá chamar automaticamente a estrutura ao chamar o objeto, não há necessidade de chamá-lo manualmente, e só será chamado uma vez
Sintaxe do destruidor: ~类名(){}
-
Destruidor, sem valor de retorno nem vazio de escrita
-
O nome da função é igual ao nome da classe, com o símbolo ~ na frente do nome
-
O destruidor não pode ter parâmetros, então a sobrecarga não pode ocorrer
-
O programa irá chamar automaticamente o destruidor antes que o objeto seja destruído, não há necessidade de chamá-lo manualmente, e ele só será chamado uma vez
#include <iostream>
using namespace std;
class Person
{
public:
//构造函数
Person()
{
cout << "Person的构造函数调用" << endl;
}
//析构函数
~Person()
{
cout << "Person的析构函数调用" << endl;
}
};
void test01()
{
Person p;
}
int main(void) {
test01();
system("pause");
return 0;
}
2. Classificação e chamada de construtores
Dois métodos de classificação:
De acordo com os parâmetros, é dividido em: estrutura de parâmetros e estrutura de não parâmetros
Dividido por tipo: estrutura comum e estrutura de cópia
class Person
{
public:
//无参（默认）构造函数
Person()
{
cout << "无参构造函数!" << endl;
}
//有参构造函数
Person(int a)
{
age = a;
cout << "有参构造函数!" << endl;
}
//拷贝构造函数
Person(const Person& p)
{
age = p.age;
cout << "拷贝构造函数!" << endl;
}
//析构函数
~Person()
{
cout << "析构函数!" << endl;
}
public:
int age;
};Três métodos de chamada:
Bracketing
Método de exibição
Conversão implícita
//2、构造函数的调用
//调用无参构造函数
void test01()
{
Person p; //调用无参构造函数
}
//调用有参的构造函数
void test02()
{
//2.1 括号法，常用
Person p1(10);
//注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
//Person p2();
//2.2 显式法
Person p2 = Person(10);
Person p3 = Person(p2);
//Person(10)单独写就是匿名对象 当前行结束之后，马上析构
//2.3 隐式转换法
Person p4 = 10; // Person p4 = Person(10);
Person p5 = p4; // Person p5 = Person(p4);
//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
//Person p5(p4);
}resultado do teste test01
resultado do teste test02
Nota 1: Você não pode adicionar parênteses ao chamar um construtor sem parâmetros. Se você adicioná-lo, o compilador o considerará uma declaração de função.
Nota 2: Você não pode usar o construtor de cópia para inicializar um objeto anônimo. O compilador o considera um declaração do objeto.
3. Quando chamar o construtor de cópia
Normalmente existem três situações quando o construtor de cópia é chamado em C ++
-
Use um objeto já criado para inicializar um novo objeto
-
Passe valor para parâmetro de função por valor
-
Retorna objetos locais por valor
(1) Use um objeto criado para inicializar um novo objeto
#include <iostream>
using namespace std;
class Person3
{
public:
Person3()
{
cout << "无参构造函数!" << endl;
mAge = 0;
}
Person3(int age)
{
cout << "有参构造函数!" << endl;
mAge = age;
}
Person3(const Person3& p)
{
cout << "拷贝构造函数!" << endl;
mAge = p.mAge;
}
//析构函数在释放内存之前调用
~Person3()
{
cout << "析构函数!" << endl;
}
public:
int mAge;
};
//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {
Person3 man(100); //p对象已经创建完毕
Person3 newman(man); //调用拷贝构造函数
Person3 newman2 = man; //拷贝构造
Person3 newman3;
newman3 = man; //不是调用拷贝构造函数，赋值操作
}
int main(void)
{
test01();
system("pause");
return 0;
}
(2) Passe o valor para o parâmetro da função na forma de passagem de valor
//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02()
{
Person p; //无参构造函数
doWork(p);
}
(3) Retorna objetos locais por valor
//3. 以值方式返回局部对象
Person doWork2()
{
Person p1;
cout << (int *)&p1 << endl;
return p1; //按照p1拷贝一个对象返回
}
void test03()
{
Person p = doWork2();
cout << (int *)&p << endl;
}
4. Regras de chamada do construtor
Por padrão, o compilador C ++ adiciona pelo menos 3 funções a uma classe
1 Construtor padrão (sem parâmetros, o corpo da função está vazio)
2 Destruidor padrão (sem parâmetros, o corpo da função está vazio)
3 O construtor de cópia padrão, copie o valor do atributo
As regras de chamada do construtor são as seguintes:
-
Se o usuário definir um construtor de parâmetro, C ++ não fornecerá mais uma construção padrão sem parâmetros, mas fornecerá uma construção de cópia padrão
-
Se o usuário definir um construtor de cópia, c ++ não fornecerá outros construtores
5. Cópia profunda e cópia superficial
Uma cópia profunda e superficial é uma pergunta de entrevista clássica e um poço comum
Cópia superficial: operação de cópia de atribuição simples
Cópia profunda: reaplicar para obter espaço na área de heap para a operação de cópia
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age)
{
m_Age = age;
cout << "有参构造函数!" << endl;
}
~Person()
{
cout << "析构函数!" << endl;
}
int m_Age;
};
void test05()
{
Person p1(18);
cout << "p1的年龄:" << p1.m_Age << endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}
Aqui irá chamar o construtor de cópia padrão do sistema
Em seguida, abra o atributo de altura na área de heap e modifique o código da seguinte maneira:
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age,int height)
{
m_Age = age;
m_Height = new int(height);
cout << "有参构造函数!" << endl;
}
~Person()
{
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "析构函数!" << endl;
}
int m_Age;
int* m_Height;
};
void test05()
{
Person p1(18,160);
cout << "p1的年龄:" << p1.m_Age << "p1的身高:"<<*p1.m_Height<< endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << "p2的身高:" << *p2.m_Height << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}O seguinte erro ocorreu
Se você usar o construtor de cópia fornecido pelo compilador, uma cópia superficial será feita.
O atributo m_Age de p1 será copiado byte a byte para m_Age de p2
O atributo int * m_Height é o espaço aberto na área de heap, que também é copiado byte por byte;
Quando o destruidor é executado, p2 executa o destruidor primeiro, ou seja, a memória na área de heap é liberada; p1 também executará o destruidor, e a memória na área de heap será liberada novamente neste momento, o que é ilegal Operação.
Este é o problema causado pela cópia superficial (liberação repetida de memória na área de heap).
Use a cópia profunda para resolver o problema da cópia superficial
#include <iostream>
using namespace std;
class Person
{
public:
Person()
{
cout << "无参构造函数!" << endl;
}
Person(int age,int height)
{
m_Age = age;
m_Height = new int(height);
cout << "有参构造函数!" << endl;
}
//自己实现拷贝构造函数 来解决浅拷贝的问题
Person(const Person& p)
{
//编译器写的
//m_Age = p.m_Age;
//m_Height = p.m_Height;
//深拷贝
m_Age = p.m_Age;
m_Height = new int(*p.m_Height);
cout << "拷贝参构造函数!" << endl;
}
~Person()
{
if (m_Height != NULL)
{
delete m_Height;
m_Height = NULL;
}
cout << "析构函数!" << endl;
}
int m_Age;
int* m_Height;
};
void test05()
{
Person p1(18,160);
cout << "p1的年龄:" << p1.m_Age << "p1的身高:"<<*p1.m_Height<< endl;
Person p2(p1);
cout << "p2的年龄:" << p2.m_Age << "p2的身高:" << *p2.m_Height << endl;
}
int main(void)
{
test05();
system("pause");
return 0;
}
Resumo: Se o atributo for desenvolvido na área de heap, você deve fornecer seu próprio construtor de cópia para evitar problemas causados por cópia superficial.
6. Lista de inicialização
efeito:
C ++ fornece sintaxe de lista de inicialização para inicializar propriedades
gramática:构造函数()：属性1(值1),属性2（值2）... {}
Forma tradicional
#include <iostream>
using namespace std;
class Person6
{
public:
//传统方式
Person6(int a, int b)
{
m_A = a;
m_B = b;
}
int m_A;
int m_B;
};
void test06()
{
Person6 p(10, 20);
cout << p.m_A << endl;
cout << p.m_B << endl;
}
int main(void)
{
test06();
system("pause");
return 0;
}
Use a lista de inicialização
#include <iostream>
using namespace std;
class Person6
{
public:
//初始化列表
Person6(int a, int b) :m_A(a), m_B(b)
{
}
int m_A;
int m_B;
};
void test06()
{
Person6 p(10, 20);
cout << p.m_A << endl;
cout << p.m_B << endl;
}
int main(void)
{
test06();
system("pause");
return 0;
}
7. Objetos de classe como membros da classe
Um membro em uma classe C ++ pode ser um objeto de outra classe, chamamos esse membro de membro-objeto
Por exemplo:
class A {}
class B
{
A a；
}A classe B tem o objeto A como membro e A é um membro do objeto
Então, ao criar um objeto de B, quem é a ordem de construção e destruição de A e B?
#include <iostream>
#include <string>
using namespace std;
//手机类
class Phone
{
public:
string p_name;
Phone(string name) :p_name(name)
{
cout << "Phone 的构造函数" << endl;
}
~Phone()
{
cout << "Phone 的析构函数" << endl;
}
};
//人类
class Person7
{
public:
//m_Phone(p_Name)相当于 Phone m_Phone(p_Name)隐式转换法
Person7(string name, string p_Name) :m_Name(name), m_Phone(p_Name)
{
cout << "Person 的构造函数" << endl;
}
~Person7()
{
cout << "Person 的析构函数" << endl;
}
string m_Name;
Phone m_Phone;
};
void test07()
{
Person7 p("张三", "华为");
cout <<p.m_Name<<"拿着" <<p.m_Phone.p_name<< endl;
}
int main(void)
{
//当类中成员是其他类对象时，我们称该成员为 对象成员
//构造的顺序是 ：先调用对象成员的构造，再调用本类构造
//析构顺序与构造相反
test07();
system("pause");
return 0;
}8. Membros estáticos
Um membro estático é adicionar a palavra-chave static antes das variáveis de membro e funções de membro, chamadas de membros estáticos
Os membros estáticos são divididos em:
-
Variável de membro estático
-
Todos os objetos compartilham os mesmos dados
-
Alocar memória durante a compilação
-
Declaração dentro da classe, inicialização fora da classe
-
-
Função de membro estático
-
Todos os objetos compartilham a mesma função
-
As funções de membro estático só podem acessar variáveis de membro estático
-
(1) Variáveis de membro estático
#include <iostream>
using namespace std;
class Person8
{
public:
static int m_A; //静态成员变量
private:
static int m_B;
};
//类内声明，类外初始化
int Person8::m_A = 100;
int Person8::m_B = 20;
void test8()
{
Person8 p1;
cout << p1.m_A << endl;
Person8 p2;
p2.m_A = 200;
cout << p1.m_A << endl; //共享一份数据
//通过类名访问
cout << Person8::m_A << endl;
//私有权限访问不到
//cout << Person8::m_B << endl;
}
int main(void)
{
test8();
system("pause");
return 0;
}
(2) Função de membro estático
#include <iostream>
using namespace std;
class Person9
{
public:
//静态成员函数
static void func()
{
m_A = 100;
//m_B = 10; //错误，不可以访问非静态成员变量
//因为静态成员函数不属于任何一个对象，而非静态成员变量必须有一个对象去指向，产生矛盾
cout << "void func调用" << endl;
}
//静态成员变量
static int m_A;
int m_B;
private:
static void func2()
{
cout << "void func2调用" << endl;
}
};
//静态成员变量初始化
int Person9::m_A = 10;
void test9()
{
//静态成员变量两种访问方式
//1、通过对象
Person9 p;
p.func();
//2、通过类名
Person9::func();
//Person9::func2(); //私有权限访问不到
}
int main(void)
{
test9();
system("pause");
return 0;
}
As funções de membro estático não podem acessar variáveis de membro não estáticas. Como as funções de membro estáticas não pertencem a nenhum objeto, as variáveis de membro não estáticas devem ter um objeto para apontar, o que cria contradições.