1. Objetos de clase como miembros de clase.
Una clase puede ser miembro de otra clase.
Código:
#include <iostream>
using namespace std;
class phone {
public:
string shouji;
phone(string shouji1) :shouji(shouji1) {
cout << "phone的构造函数调用" << endl;
}
~phone() {
cout << "phone的析构函数调用" << endl;
}
};
class person {
public:
int age;
string name;
phone shouji;
//隐式转换相当于shouji=phone(shouji1)
person(int a, string name1, string shouji1) :age(a), name(name1), shouji(shouji1) {
cout << "person的构造函数调用" << endl;
}
~person() {
cout << "person的析构函数调用" << endl;
}
};
void fun() {
person p(23, "小明", "苹果");
}
int main() {
fun();
return 0;
}
Aviso:
Al crear una clase, primero se llama al constructor de la clase contenida y luego al constructor de la clase externa. Cuando se destruye 1, ocurre todo lo contrario: primero se destruye la clase externa y luego se destruye la clase interna. .
2. Miembros estáticos
Los miembros estáticos se denominan miembros estáticos agregando la palabra clave estática delante de las variables miembro.
Los miembros estáticos se dividen en variables miembro estáticas y funciones miembro estáticas .
2.1 Variables miembro estáticas
. Todos los objetos comparten los mismos datos.
. La memoria se asigna durante la fase de compilación.
. Declaración en clase, inicialización fuera de clase · función miembro estática
Los miembros estáticos deben inicializarse fuera de la clase; de lo contrario, el compilador pensará que solo están declarados pero no definidos y se producirá un error de enlace.
Código:
#include <iostream>
using namespace std;
class person {
public:
static int age;
};
int person::age = 10;
void fun() {
person p;
p.age = 90;
person p1;
cout << p1.age << endl;
}
int main() {
fun();
return 0;
}Se puede acceder a las variables miembro estáticas no solo a través de objetos, sino también a través de nombres de clases. Las variables miembro estáticas también tienen derechos de acceso.
Código:
#include <iostream>
using namespace std;
class person {
public:
static int age;
};
int person::age = 10;
void fun() {
person p;
p.age = 90;
cout << person::age << endl;
}
int main() {
fun();
return 0;
}2.2 Funciones de miembros estáticos
. Todos los objetos comparten la misma función.
. Las funciones miembro estáticas solo pueden acceder a variables miembro estáticas
Código:
#include <iostream>
using namespace std;
class person {
public:
static int age;
static void fun(int a) {
age = a; //只能调用静态成员变量
cout << "静态函数fun调用" << endl;
}
};
int person::age = 100;
void dioayong() {
person p;
p.fun(99); //对象调用
person::fun(66); //类名调用
cout << p.age << endl;
}
int main() {
dioayong();
return 0;
}De manera similar, las funciones miembro estáticas también se pueden llamar mediante nombres de clase. Cabe señalar que las funciones miembro estáticas solo pueden llamar a variables miembro estáticas.
3.este puntero
3.1 Almacenamiento de variables miembro y funciones.
En C++, las variables miembro y las funciones miembro dentro de una clase se almacenan por separado
Sólo las variables miembro no estáticas pertenecen a objetos de la clase.
En C++, las clases vacías también ocupan un byte. El compilador de C++ también asignará un espacio de bytes para cada objeto vacío para distinguir la ubicación del objeto en la memoria .
Código:
#include <iostream>
using namespace std;
class person {
};
void fun() {
person p;
cout<<sizeof(p);
}
int main() {
fun();
return 0;
}
La clase también tiene la característica de alineación de la memoria.
Código:
#include <iostream>
using namespace std;
class person {
public:
int a;
char b;
};
void fun() {
person p;
cout<<sizeof(p);
}
int main() {
fun();
return 0;
}
Además, ni las funciones miembro ni las variables miembro estáticas se almacenan en la clase, es decir, solo las variables miembro no estáticas se almacenan en la clase.
Código:
#include <iostream>
using namespace std;
class person {
public:
int a;
static int b;
void fun() {
cout << "fun函数调用" << endl;
}
static void fun1() {
cout << "fun1函数调用" << endl;
}
};
int person::b = 10;
void fun() {
person p;
cout<<sizeof(p);
}
int main() {
fun();
return 0;
}
3.2Uso de este puntero
Cada función miembro no estática solo creará una instancia de función , lo que significa que varios objetos del mismo tipo compartirán un fragmento de código, por lo que la pregunta es: ¿cómo distingue este fragmento de código qué objeto se llama a sí mismo?
C++ resuelve los problemas anteriores proporcionando un puntero de objeto especial, el puntero this . Este puntero apunta al objeto al que pertenece la función miembro llamada.
Aviso:
1.Este puntero es un puntero implícito en cada función miembro no estática.
2. No es necesario definir este puntero, se puede utilizar directamente
El propósito de este puntero:
·Cuando los parámetros formales y las variables miembro tienen el mismo nombre, este puntero se puede utilizar para distinguir los parámetros formales y las variables con el mismo nombre.
·Para devolver el objeto en sí en una función miembro no estática de una clase, utilice return *this
Código:
#include <iostream>
using namespace std;
class people {
public:
int age;
people(int age) {
this->age = age;
}
};
void zhixing() {
people p(10);
cout << p.age << endl;
}
int main() {
zhixing();
return 0;
}Al devolverlo a sí mismo, tenga cuidado de devolver un tipo de referencia. Al devolver un tipo de valor común, el valor de retorno es una copia de sí mismo.
#include <iostream>
using namespace std;
class people {
public:
int age;
people(int age) {
this->age = age;
}
people& add(const people& p) {
this->age += p.age;
return *this;
}
};
void zhixing() {
people p1(10);
people p2(20);
p2.add(p1).add(p1).add(p1).add(p1);
cout << p2.age << endl;
}
int main() {
zhixing();
return 0;
}4. Acceso de puntero nulo a funciones miembro
En C++, los punteros nulos también pueden llamar a funciones miembro, pero también se debe prestar atención a si se utiliza este puntero.
Código:
#include <iostream>
using namespace std;
class person {
public:
int age;
void fun1() {
cout << "fun1调用" << endl;
}
void fun2() {
cout << "fun2调用" << age << endl;
}
};
void diaoyong() {
person* p = NULL;
p->fun1();
p->age = 10;
p->fun2();
}
int main() {
diaoyong();
return 0;
}
Sólo las funciones sin estos punteros se pueden llamar con éxito, porque en este momento se trata de un puntero nulo y las llamadas que lo contienen
Código:
#include <iostream>
using namespace std;
class person {
public:
int age;
void fun1() {
cout << "fun1调用" << endl;
}
void fun2() {
if (this == NULL) {
return;
}
cout << "fun2调用" << age << endl;
}
};
void diaoyong() {
person* p = NULL;
p->fun1();
p->fun2();
}
int main() {
diaoyong();
return 0;
}Aumente la solidez del código y salte de la función cuando se considere que este puntero es un puntero nulo.
5. función miembro modificada constante
Función constante:
1. Después de agregar const a la función miembro, llamamos a esta función función constante.
2. Los atributos de los miembros no se pueden modificar dentro de una función constante.
3. Después de agregar la palabra clave mutable al declarar un atributo de miembro , aún se puede modificar en una función constante.
Objetos comunes:
1. Agregue const antes de declarar un objeto para llamarlo objeto constante.
2. Los objetos constantes solo pueden llamar a funciones constantes y variables miembro modificadas con mutable .
5.1 Funciones constantes
La esencia de este puntero es una constante de puntero: el puntero al que apunta no se puede modificar (persona * const this), pero el valor de la dirección a la que apunta este puntero se puede cambiar.
La función constante constante debe agregarse después de la lista de parámetros de la función.
Código:
#include <iostream>
using namespace std;
class person {
public:
int age;
void showage(int m) const{
// age = 89; //报错
m = 100;
cout << "age=" << age <<" m=" << m << endl;
}
};
void fun() {
person p;
p.age = 10;
p.showage(7);
}
int main() {
fun();
return 0;
}
En este momento, el compilador informará un error y la edad no se puede cambiar dentro de la función. Pero los parámetros pasados por la función aún se pueden cambiar.
#include <iostream>
using namespace std;
class person {
public:
mutable int age;
void showage(int m) const{ //常函数
age = 89; //报错
m = 100;
cout << "age=" << age <<" m=" << m << endl;
}
};
void fun() {
person p;
p.age = 10;
p.showage(7);
}
int main() {
fun();
return 0;
}Después de agregar la palabra clave mutable al declarar un atributo de miembro, aún se puede modificar en una función constante.
5.2 Objetos constantes
Código:
#include <iostream>
using namespace std;
class person {
public:
mutable int age;
void showage1(int m) const{
//age = 89; //报错
m = 100;
cout << "age=" << age <<" m=" << m << endl;
}
void showage2(int m) {
age = 89;
m = 100;
cout << "age=" << age << " m=" << m << endl;
}
};
void fun() {
const person p;
p.age = 10;
p.showage1(7);
//p.showage2(7); 报错
}
int main() {
fun();
return 0;
}Los objetos constantes solo pueden llamar a funciones constantes y variables miembro modificadas con mutables. No se pueden llamar funciones ordinarias ni variables miembro ordinarias
6. Youyuan
Palabra clave de amigo: amigo
Tres implementaciones de amigos:
1. Funciones globales como amigos
2. Las clases hacen amigos
3. Las funciones de los miembros actúan como amigos.
6.1 Funciones globales como amigos
Código:
#include <iostream>
using namespace std;
class home {
friend void func(home& p);
public:
home(string keting, string woshi, string cuosuo):keting(keting),woshi(woshi),cuosuo(cuosuo) {
}
string keting;
private:
string woshi;
protected:
string cuosuo;
};
void func(home &p) {
cout << p.keting << ' ' << p.woshi << ' ' << p.cuosuo << endl;
}
void fun() {
home p("客厅", "卧室", "厕所");
func(p);
}
int main() {
fun();
//cout << p.keting << ' ' << p.woshi << ' ' << p.cuosuo << endl;
//保护和私有属性的不能访问
return 0;
}
Una función elemental no es una función miembro de la clase, pero tiene permiso para llamar a todas las variables miembro de la clase.
6.2 Categoría Amistad
#include <iostream>
using namespace std;
class building {
friend class goodgay; //声明友元类
public:
building();
string keting;
private:
string cesuo;
protected:
string woshi;
};
building::building() {
keting = "客厅";
cesuo = "厕所";
woshi = "卧室";
}
class goodgay {
public:
goodgay();
void show();
private:
building* p;
};
void goodgay::show() {
cout << this->p->keting << ' ' << this->p->cesuo << ' ' << this->p->woshi << endl;
}
goodgay::goodgay() {
p = new building;
}
void f() {
goodgay a;
a.show();
}
int main() {
f();
return 0;
}
Cuando una clase es amiga, todas las funciones miembro de la clase pueden acceder a todos los miembros de la clase amiga.
6.3 Los miembros funcionan como amigos
Código:
#include <iostream>
using namespace std;
class building;
class goodgay {
public:
goodgay();
void show1(building& p);
private:
building* p;
};
class building {
friend void goodgay::show1(building& p); //声明友元类
public:
building();
string keting;
private:
string cesuo;
protected:
string woshi;
};
building::building() {
keting = "客厅";
cesuo = "厕所";
woshi = "卧室";
}
void goodgay::show1(building& p1) {
cout <<p1.keting << ' ' << p1.cesuo << ' ' << p1.woshi << endl;
}
//void goodgay::show2() {
// cout << this->p->ketipng << ' ' << this->p->cesuo << ' ' << this->p->woshi << endl;
//}
//无权限
goodgay::goodgay() {
p = new building;
}
void f() {
goodgay a;
building b;
a.show1(b);
}
int main() {
f();
return 0;
}Tenga en cuenta que la clase debe declararse primero para evitar errores. A diferencia de ser amiga de una función global, se debe agregar un alcance.