前言
C++中的类(class)是实现数据抽象和面向对象程序设计的核心。本文作为类和对象的开篇,将介绍有关类的基础知识,之后会持续更新类和对象的深入内容。
目录
前言
1 类的引入
2 类的定义
3 访问限定符和封装
3.1 访问限定符
3.2 封装
4 类的实例化及类对象的储存
4.1 实例化
4.2 类对象的储存
4.3 类的大小计算
5 this指针
5.1 this指针的引入
5.2 this能否为空指针
5.3 代码规范
1 类的引入
C++兼容C语言,C语言中的结构(struct)在C++中扩充成了类。
struct Stack
{
// ...
};
struct Stack st1; // C语言定义结构体变量
Stack st2; // C++创建类对象
C语言结构体中只能定义变量,在C++中,结构体不仅可以定义变量,也可以定义函数。
struct Stack
{
// 成员函数
void Init()
{
a = nullptr;
top = capacity = 0;
}
void Push(int x)
{
// ...
}
// 成员变量
int* a;
int top;
int capacity;
};
Stack st;
st.Init(); // 使用:类对象.成员变量/成员函数
st.Push(1);
2 类的定义
class className
{
// 类体
};
class为定义类的关键字,className为类的名字,{}中为类的主体。类体中的内容为类的成员:成员变量(类的属性),成员函数(类的方法)。
类域:类定义了一个新的作用域,类的所有成员都在类域中,在类体外定义的成员需要作用域限定符::指定它属于哪个类域。
类的定义方式:
1.声明和定义全部放在类体中。成员函数在类中定义可能会被编译器当作内联函数处理。
2.类声明放在.h文件中,成员函数定义放在.cpp文件中(成员函数前需加 类名::)
3 访问限定符和封装
3.1 访问限定符
访问限定符分为:public(公有),protected(保护)和private(私有)
说明:
- public修饰的成员在类外可以直接被访问
- protected和private修饰的成员在类外不能直接被访问
- 作用域从该访问限定符开始直到下一个访问限定符出现或类结束
- class的默认访问权限为private,struct为public
3.2 封装
将数据和操作数据的方法进行有机结合,隐藏对象的属性和实现细节,仅对外公开接口来和对象进行交互。
// .h文件中声明成员函数
class Stack
{
public:
void Init();
void Push(int x);
int Top();
private:
int* a;
int top;
int capacity;
};
// .cpp文件中定义成员函数
void Stack::Init()
{
a = nullptr;
top = capacity = 0;
}
void Stack::Push(int x)
{
if (top == capacity)
{
int newCapacity = (capacity == 0 ? 4 : capacity * 2);
int* tmp = (int*)realloc(a, sizeof(int) * newCapacity);
if (tmp == nullptr)
{
perror("relloc fail");
return;
}
a = tmp;
capacity = newCapacity;
}
a[top++] = x;
}
int Stack::Top()
{
return a[top - 1];
}
int main()
{
Stack st;
int top = st.Top();
// st.a[st.Top] 不能访问
return 0;
}
如上定义栈类(Stack),成员变量top初始为0指向栈顶元素下一个位置,用户可能认为top指向栈顶元素,通过访问成员变量获取栈顶元素(st.a[st.top])出错,因此通过将Stack进行封装,将类的属性设为私有,用类的方法Top()实现获取栈顶元素供用户使用。
4 类的实例化及类对象的储存
4.1 实例化
用类创建对象的过程称为类的实例化。类就像是一种模型,对对象进行描述,限定了类有哪些成员,定义一个类并没有分配实际的空间来储存它,一个类可以实例化出多个对象,实例化出的对象才占用实际的物理空间。
4.2 类对象的储存
定义一个类,它的成员变量实际是一种声明,只有实例化出的对象才会定义这些成员变量,因此实例化类对象需要开辟物理空间储存成员变量,那么类的成员函数需要每个对象储存吗,类的成员函数不仅要在类中声明,也要在类中定义,每个对象都可以使用类的成员函数,所以类的成员函数不需要实例化对象储存,事实上它们也不需要类储存,因为它们存放在公共代码区。
4.3 类的大小计算
那么计算类的大小只需要计算类中的成员变量,其计算方式遵循结构体内存对齐规则。
结构体内存对齐规则:
1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字(对齐数)的整数倍的地址处。
注意:对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的对齐数为8
3. 结构体总大小为:最大对齐数(所有变量类型最大者与默认对齐参数取最小)的整数倍。
4. 如果嵌套了结构体的情况,嵌套的结构体对齐到自己的最大对齐数的整数倍处,结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。
如创建三个类,它们分别是空类、只含成员函数的类、只含成员变量的类、含成员变量和成员函数的类,分别计算它们的大小。
// 空类
class A
{
};
// 类中仅有成员函数
class B
{
public:
void Func()
{
}
};
// 类中仅有成员变量
class C
{
private:
int a;
int b;
int c;
};
// 类中既有成员函数又有成员变量
class D
{
public:
void Func()
{
}
private:
int a;
int b;
int c;
};
int main()
{
cout << "sizeof(A) " << sizeof(A) << endl;
cout << "sizeof(B) " << sizeof(B) << endl;
cout << "sizeof(C) " << sizeof(C) << endl;
cout << "sizeof(D) " << sizeof(D) << endl;
return 0;
}
结果:
C类含3个整型其大小为12字节,D类和C类的大小相同,可以验证成员函数不需要类储存,A类和B类的大小都为1,是因为编译器给空类(包括只含成员函数的类)一个字节用来标识。
5 this指针
5.1 this指针的引入
class Date
{
public:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
void Print()
{
cout << _year << '/' << _month << '/' << _day << endl;
}
private:
int _year;
int _month;
int _day;
};
int main()
{
Date d1;
Date d2;
d1.Init(2022, 7, 20);
d2.Init(2022, 7, 21);
return 0;
}
如上定义一个日期类,创建两个对象d1,d2,类中的函数没有关于不同对象的区分,当d1调用Init()函数时,函数是如何将参数传给对象d1的成员变量(_year,_month,_day)而不是对象d2的呢?
C++中引入this指针解决该问题,即:类的每个成员函数有一个隐藏的指针参数this,当对象调用函数时会将对象的地址传给函数的this指针,函数内所有成员变量的操作都通过this指针去访问。this指针的设置和传参由编译器自动完成,用户不能显式写出,在函数体内可以使用。
this指针的特性:
- this指针的类型:类类型* const,在成员函数中不能给this指针赋值。
- this指针是成员函数的第一个隐含指针形参,对象调用成员函数时将对象地址作为实参传递给this指针,对象中不储存this指针。
- this指针由编译器通过ecx寄存器自动传递,不需要用户传递。
函数调用实际实现如下:
void Init(Date* const this, int year, int month, int day)
{
this->_year = year;
this->_month = month;
this->_day = day;
}
void Print(Date* const this)
{
cout << this->_year << '/' << this->_month << '/' << this->_day << endl;
}d1.Init(&d1, 2022, 7, 20);
d1.Print(&d1);
通过验证,发现:对象d1,d2调用Init()和Print()函数时,函数的this指针的值和它们本身地址相同。
5.2 this能否为空指针
在一般情况下,不能对空指针进行解引用操作,所以类对象的指针不能为空,this指针也就不能为空。如果类的成员函数中没有对this指针的实际解引用,即便给this传空指针也不会出现问题。
如下程序会正常执行:
p->Print()或(*p).Print()好像是对空指针p进行了解引用,实际上它调用Print()函数时会直接把p传给this,因为实参&(*p)和p是相同的。这种情况在实际中可能很少出现,但它是可行的。
如下程序就会运行崩溃:
因为Print()函数内对成员变量进行操作,访问_a需要对this指针进行解引用,this->_a,对空指针解引用引起运行崩溃。
5.3 代码规范
1.this指针为何失灵?
class Date
{
public:
void Init(int year, int month, int day)
{
year = year;
month = month;
day = day;
}
void Print()
{
cout << year << '/' << month << '/' << day << endl;
}
private:
int year;
int month;
int day;
};
执行以上程序,输出的却是随机值,说明对象d1调用了Init()函数但是d1的成员变量并没有初始化,这是为什么呢?
其原因是函数Init()内的year,month,day变量都是局部变量(函数形参),比如year = year,我们期望左边的year是类的成员变量year,右边是函数形参year,事实上左边的year也是函数的形参,因为year是存在的局部变量,函数内的year自然都优先与它对应,编译器不会“智能”地对左边的变量使用this->访问,它就不会对应类的成员变量。以上操作如同定义一个变量int a;,再赋值变量给它自己 a = a;
因此要实现我们的期望,就有两种方法:显式使用this指针或改变变量名。
2.显式使用this指针
通过显式使用this指针,将左边的变量设为类的成员变量,即:
void Init(int year, int month, int day)
{
this->year = year;
this->month = month;
this->day = day;
}
3.成员变量书写规范
将类成员函数的参数与类成员变量书写不同就能避免this指针失灵的问题。常见的代码书写规范是在类的成员变量前或后加_,即:
void Init(int year, int month, int day)
{
_year = year;
_month = month;
_day = day;
}
private:
int _year;
int _month;
int _day;
如果要在函数内使用全局变量,其参数也不能和全局变量重名,否则会将全局的名字隐藏,因此规范的变量命名是解决一些问题的通用方法,一般不使用第一种方法(显示使用this指针)。
如果本文内容对你有帮助,可以点赞收藏,感谢支持,期待你的关注。文章来源:https://www.toymoban.com/news/detail-693706.html
下篇预告:C++ 类和对象(二)构造函数、析构函数、拷贝构造函数文章来源地址https://www.toymoban.com/news/detail-693706.html
到了这里,关于C++ 类和对象(一)类、访问限定符、this指针的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!