Répertoire d'articles
Un, classe et objet
1. Paquet
2. Initialisation et nettoyage des objets
(5) Copie profonde et copie superficielle
La copie profonde est une question d'entrevue classique et une fosse commune
- Copie superficielle: Si vous utilisez le constructeur de copie fourni par le compilateur, vous effectuerez une opération de copie superficielle, qui est une simple opération de copie d'affectation
- Copie profonde: réappliquez de l'espace dans la zone du tas pour l'opération de copie
Si l'attribut est développé dans la zone de tas, vous devez fournir votre propre constructeur de copie pour éviter les problèmes causés par une copie superficielle
Exemple
#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) Liste d'initialisation
Rôle: C ++ fournit la syntaxe de la liste d'initialisation pour initialiser les propriétés
grammaire:构造函数 （ ）：属性1（值1），属性2（值2）......{ }
Exemple
#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) Objets de classe en tant que membres de la classe
Un membre en C ++ peut être un objet d'une autre classe, nous appelons ce membre un membre objet
Lorsque d'autres objets de classe sont utilisés comme membres de cette classe, l'objet de classe est construit en premier, puis lui-même
Par exemple
class A {
}
class B
{
A a;
}
B类中有对象A作为成员，A为对象成员
Exemple
#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;
}
Résultat de sortie
(8) Membres statiques
Un membre statique consiste à ajouter le mot-clé static avant les variables membres et les fonctions membres, appelées membres statiques
Les membres statiques sont divisés en:
1 * variable membre statique
- Tous les objets partagent les mêmes données
- Allouer de la mémoire lors de la compilation
- Déclaration en classe, initialisation hors classe
2 * fonction membre statique
- Tous les objets partagent la même fonction
- Les fonctions membres statiques ne peuvent accéder qu'aux variables membres statiques
Les fonctions membres statiques ont également des droits d'accès: les fonctions membres statiques privées ne sont pas accessibles en dehors de la classe
Exemple
#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. Modèle objet C ++ et ce pointeur
(1) stockage séparé des variables membres et des fonctions membres
En C ++, les variables membres et les fonctions membres d'une classe sont stockées séparément
Seules les variables membres non statiques appartiennent aux objets de la classe
Le compilateur C ++ allouera chaque objet videUn espace d'octet, C'est pour distinguer l'emplacement mémoire occupé par l'objet, chaque objet vide doit avoir une adresse mémoire unique
- Variables membres non statiques: sur les objets appartenant à la classe
- Variables membres statiques: sur les objets n'appartenant pas à la classe
- Fonction membre non statique: sur les objets n'appartenant pas à la classe
- Fonction membre statique: sur les objets n'appartenant pas à la classe
(2) Le concept de ce pointeur
L'essence de ce pointeur est une constante de pointeur, le pointeur ne peut pas être modifié, mais la valeur peut être modifiée
Chaque fonction membre non statique ne produira qu'une instance de fonction, ce qui signifie que plusieurs objets du même type partageront un morceau de code
C ++ résout les problèmes ci-dessus en fournissant un pointeur d'objet spécial, ce pointeur
Le pointeur this pointe vers l'objet vers lequel la fonction membre est appelée
- Ce pointeur est un pointeur qui implique chaque fonction membre non statique
- Ce pointeur n'a pas besoin d'être défini, il peut être utilisé directement
Le but de ce pointeur:
- Lorsque le paramètre formel et la variable membre ont le même nom, le pointeur this peut être utilisé pour distinguer (résoudre les conflits de nom)
- Pour renvoyer l'objet lui-même dans la fonction membre non statique de la classe, vous pouvez utiliser return this ( utilisez ceci pour renvoyer l'objet lui-même )
Exemple
#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) Accès pointeur nul aux fonctions membres
Les pointeurs nuls en C ++ peuvent également appeler des fonctions membres, mais aussi faire attention à l'utilisation ou non du pointeur this
Si ce pointeur est utilisé, il doit être jugé pour garantir la robustesse du code
Exemple
#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) fonction membre modifiée const
Fonction constante:
- Après avoir ajouté const après la fonction membre, nous appelons cette fonction une fonction constante
- Les propriétés des membres ne peuvent pas être modifiées dans les fonctions constantes
- Après avoir ajouté le mot-clé mutable dans la déclaration d'attribut membre, il peut toujours être modifié dans la fonction normale
Objet régulier:
- Ajouter const avant de déclarer l'objet pour appeler l'objet un objet constant
- Les objets constants ne peuvent appeler que des fonctions constantes
Exemple
#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;
}
[Note] Le cours d’apprentissage est le didacticiel C ++ du programme Dark Horse