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.
Jetez d'abord un œil à l'espace occupé par les objets vides:
#include <iostream>
using namespace std;
//成员变量和成员函数是分开存储的
class Person {
};
void test01() {
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
int main() {
test01();
system("pause");
return 0;
}
Le résultat est la taille de p = 1;
L'espace mémoire occupé par les objets vides est: 1
Pourquoi est-ce 1?
Parce que le compilateur C ++ alloue également un espace d'octets pour chaque objet vide, afin de distinguer l'emplacement mémoire de l'objet vide.
Chaque objet vide doit également avoir une adresse mémoire unique, de sorte que le compilateur allouera un octet à chaque objet vide comme distinction.
Maintenant, nous donnons int m_A à l'objet vide et voyons quel est le résultat?
code montrer comme ci-dessous:
#include <iostream>
using namespace std;
//成员变量和成员函数是分开存储的
class Person {
int m_A;//非静态变量 属于类对象上的数据
};
void test01() {
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
int main() {
test01();
system("pause");
return 0;
}
Le résultat est la taille de p = 4
Description: La
variable non statique m_A appartient à l'objet de la classe
Maintenant, nous allons à static int m_B dans la classe et voyons quel est le résultat?
void func () // Fonction non statique, quel est le résultat?
Qu'en est-il de static void func2 ()?
code montrer comme ci-dessous:
#include <iostream>
using namespace std;
//成员变量和成员函数是分开存储的
class Person {
int m_A;
static int m_B;//静态成员变量
void func()
{
}
static void func2()
{
}
};
int Person::m_B = 0;//静态成员变量特点，类内声明，类外初始化。不属于类对象上
void test01() {
Person p;
cout << "size of p = " << sizeof(p) << endl;
}
int main() {
test01();
system("pause");
return 0;
}
Le résultat est toujours: 4
1. Expliquez que la variable membre statique n'appartient pas à l'objet de classe.
2. Expliquez que les fonctions membres (y compris statiques et non statiques) sont stockées séparément des variables membres.
Chaque fonction membre non statique ne produira qu'une instance de fonction, c'est-à-dire que plusieurs objets du même type partageront un morceau de code, alors la question est:
comment ce morceau de code distingue-t-il quel objet s'appelle lui-même?
C ++ résout les problèmes ci-dessus en fournissant un pointeur d'objet spécial, ce pointeur.