细谈C++中的“类和对象”

于 2019-01-17 20:53:13 发布
阅读量271 收藏 1
点赞数
CC 4.0 BY-SA版权
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/tangya3158613488/article/details/86528633
本文深入探讨C++中类和对象的概念，包括类的定义、成员函数、封装、继承和多态等特性。详细解析类的实例化、内存对齐、this指针以及类的六大默认成员函数，如构造函数、析构函数、拷贝构造函数等。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

类和对象

通过C语言的学习，我们了解到C语言是面向过程的，关注的是过程，分析求解问题的步骤，通过函数调用逐步解决问题。而现在所学的C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间交互完成。类是对象的抽象或模型，而对象时类的实例下面我们将一一看到C++中类和对象的相关运用。

  • 类的定义
class className
{
  //主体：由成员函数和成员变量组成
};//后面有分号，和struct和union类似

class是定义类的关键字，className是类的名字，类中的元素称为类的成员，类中的数据称为类的属性或成员变量，类中的函数称为类的方法或成员函数。

类的两种定义方式：

  • 声明和定义全部放在类体中，须注意的是：成员函数放在类中定义，编译器可能会将其当成内联函数处理。

  • 声明放在.h文件中，定义放在.cpp中（一般采用这种方式），在类外定义需要是（ 类名::函数名）指明成员属于哪个类域。

  • 类的访问限定符及封装

  • 类的访问限定符有：public（共有），private（私有），protected(保护)。
    说明：
    1.public修饰的成员在类外可以直接被访问，而private和protected修饰的成员在类外不能直接被访问。
    2.访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止。
    3.class的默认访问权限为private，struct的默认访问权限为public（因为struct要兼容C）。
    【面试题】
    问题：C++中struct和class的区别是什么？
    解答：C++需要兼容C语言，所以C++中的struct可以当成结构体去使用。另外C++中的struct可以用来定义类，和class定义类一样。区别是struct的成员默认方式是public，class的成员默认访问方式是private

  • 封装
    【面试题】
    问题：面向对象的三大特性：封装、继承、多态。在类和对象阶段，我们只研究类的封装特性，那什么是封装呢？
    解答：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
    封装本质上是一种管理，我们使用protected或private把成员封装起来，开放一些共有的成员函数对成员合理的访问。

  • 类的实例化
    用类类型创建对象的过程，称为类的实例化。类只是一个模型，定义出一个类并没有分配实际的内存空间来存储它，但一个类实例化出多个对象时，实例化出的对象占用实际的物理空间，存储类成员变量。

  • 计算类对象的大小

//类中既有成员变量，又有成员函数
class A1
{
public:
    void f1()
    {}
private:
    int _a;
    //类中仅有成员函数
};
class A2
{
public:
   void f2()
   {}
};
//类中什么也没有（空类）
class A3
{};

//通过编译运行测得sizeof(A1)为4，sizeof(A2)为1，sizeof(A3)为1

结论：一个类的大小实际就是该类中成员变量之和，当然也要进行内存对齐。但要注意空类的大小，编译器给空类一个字节来唯一表示这个类。
注意：空类表示这个类实际存在，所以给空类一个字节来唯一标识。
补充一下结构体的内存对齐规则：
1.第一个成员在与结构体偏移量为0的地址处。
2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
在VS编译器下的默认对齐数为8，gcc中的默认对齐数为4。
3.结构体的大小为：最大对齐数（所有变量类型最大者与默认对齐数取最小的）的整数倍。
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
如果要修改默认对齐数就要用#pragma这个预处理指令

#include<iostream>
using namespace std;
//#pragma pack(自己定义的默认对齐数)要取消时括号中不填写
struct s1
{
	char a;
	int i;
	char c;
};
int main()
{
	cout << sizeof(s1) << endl;
	return 0;
}

注意：使用内存对齐虽然浪费空间，但提高了存储效率。

  • this指针

先定义一个时期类Date

#include<iostream>
using namespace std;
class Date
{
public:
   void Show()
   {
     cout << _year << "-"<< _month << "-"<< _day << endl;
   }
  Date(int year,int month,int day)
  {
     _year = year;
     _month = month;
     _day = day; 
  }
private:
  int _year;
  int _month;
  int _day;
};
int main()
{
   Date d1(2019,1,17);
   d1.Show();
   Date d2(2018,5,24);
   d2.Show();
   return 0;
}

C++编译器给每个“成员函数”增加了一个隐藏的this指针，**让该指针指向当前对象（函数运行时调用该函数的对象），在函数体中所有成员变量的操作，都是通过该指针取访问，只不过所有的操作对用户时透明的，即用户不需要来传递，编译器自动完成。

  • this指针的特性
    1.this指针的类型：类类型* const;
    2.只能在“成员函数“的内部使用；
    3.this指针本质上是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针；
    4.this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。
    所以this指针存在栈帧或寄存器，看具体的平台。
    this指针不能为空，空指针不能解引用来访问成员
#include<iostream>
using namespace std;
class A
{
 public:
  void PrintA()
  {
    cout << _a <<endl;
  }
  void Show()
  {
     cout << "Show()" << endl;
  }
  private:
  int _a;
};
int main()
{  
   A* p = NULL;
   p->PrintA();//能编译通过，不能运行通过
   p->Show();//编译通过，运行通过
}

类的6个默认成员函数

1.构造函数

构造函数是一个特殊的成员函数，名字和类名相同，创建类类型对象时由编译器自动调用，保证每个数据成员都有一个合适的初始值，并且在对象的生命周期内只调用一次。
需要注意的是，构造函数的名称叫构造，但是构造函数的主要任务并不是开空间创建对象，而是初始化对象。
构造函数的特征：

  • 函数名与类名相同。
  • 无返回值。
  • 对象实例化时编译器自动调用对应的构造函数。
  • 构造函数可以重载。
    构造函数分为无参构造和带参构造函数。
class Date
{
public:
	//1.无参构造函数
	Date()
	{}
	//2.带参构造函数
	Date(int year,in month,int day)
	{
		_year=year;
		_month=month;
		_day=day;
	}
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1;//调用无参构造函数
	Date d2(2019,10,1);//调用带参构造函数
	//注意：如果无参构造函数创建对象时，对象后面不用跟括号，否则就变成了函数的声明。
}

如果类中没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数，一旦用户显示定义，编译器将不再生成。
无参的构造函数和全缺省的构造函数都称为默认构造函数，并且默认构造函数只能有一个。注意：无参构造函数、全缺省构造函数、我们没写编译器默认生成的构造函数，都可以认为是默认成员函数。
构造函数调用之后，对象中已经有一个初始值，但不能将其称为类对象成员的初始化，构造函数体重的语句只能将其称为赋初值，而不能称作初始化。因为初始化只能初始化一次，而构造函数体内可以多次赋值。

初始化列表

初始化列表：以一个冒号开始，接着是一个以逗号分隔的数据成员列表，每个“成员变量”后面跟一个放在括号中的初始值或表达式。

class Date
{
public:
	Date(int year,int month,int day)
		:_year(year)
		,_month(month)
		,_day(day)
	{}
private:
	int _year;
	int _month;
	int _day;
};

注意：
1.每个成员变量在初始化列表中只能出现一次（初始化只能初始化一次）
2.类中包含以下成员，必须放在初始化列表位置进行初始化：

  • 引用成员变量
  • const成员变量
  • 类类型成员（该类没有默认构造函数）

3.尽量初始化列表初始化，因为不管你是否使用初始化列表，对于自定义类型成员变量，一定会先使用初始化列表初始化。
4.成员变量在类中的声明次序就是其在初始化列表中的初始化顺序，例如以下程序会出错：

class Array
{
public:
	Array(int size)
		:_size(size)
		,_array((int*)malloc(sizeof(int)*_size))//先执行
	{}
private:
	int* _array;
	int _size;
};

避免错的方法就是让声明的顺序和定义的顺序保持一致。

explicit关键字
构造函数不仅可以构造与初始化对象，对于单个参数的构造函数，还具有类型转换的作用

class Date
{
public:
	Date(int year)
		:_year(year)
	{}
	/*explicit Date(int year)
		:_year(year)
	{}*/
private:
	int _year;
	int _month;
	int _day;
};
void Test()
{
	Date d1(2019);
	d1=2018;
	//用一个整形变量给日期类对象赋值，实际编译器背后会用2018构造一个无名对象，最后用无名对象给d1对象进行赋值
}

上述代码其实可读性并不是很好，如果用explicit修饰构造函数，将会禁止单参构造函数的隐式转换。

2.析构函数

前面我们已经知道用一个类创建一个对象就要调用类的构造函数，那最后这个对象又是怎么没的呢？这就需要析构函数
但析构函数并不是完成对象的销毁，局部对象销毁工作由编译器完成的。对象在销毁时会自动调用析构函数，完成类的一些资源清理工作。

析构函数的特征：

  • 析构函数名在类名前加上字符~
  • 无参数和返回值
  • 一个类有且只有一个析构函数。若未显示定义，系统会自动生成默认的析构函数
  • 对象生命周期结束时，C++编译系统自动调用析构函数。
typedef int DataType;
class SeqList
{
public :
	SeqList (int capacity = 10)
	{
		_pData = (DataType*)malloc(capacity * sizeof(DataType));
		assert(_pData);
		_size = 0;
		_capacity = capacity;
	}
	~SeqList()
	{
		if (_pData)
		{
			free(_pData ); // 释放堆上的空间
			_pData = NULL; // 将指针置为空
			_capacity = 0;
			_size = 0;
		}
	}
private :
	int* _pData ;
	size_t _size;
	size_t _capacity;
};
//编译器生成的默认析构函数，对会自定类型成员调用它的析构函数。
class String
{
public:
	String(const char* str = "jack")
	{
		_str = (char*)malloc(strlen(str) + 1);
		strcpy(_str, str);
	}
	~String()
	{
		cout << "~String()" << endl;
		free(_str);
	}	
private:
	char* _str;
};
class Person
{
private:
	String _name;
	int _age;
};
int main()
{
	Person p;
	return 0;
}

3.拷贝构造函数

拷贝构造函数的特征：

  • 拷贝构造函数是构造函数的一个重载形式。
  • 拷贝构造函数的参数只有一个且必须使用引用传参，使用传值方式会引发无穷递归调用
  • 若未显示定义，系统生成默认的拷贝构造函数。 默认的拷贝构造函数对象按内存存储按字节序完成拷
    贝，这种拷贝我们叫做浅拷贝，或者值拷贝

在这里插入图片描述

Date(const Date& date)
{
	_year=date.year;
	_month=date.month;
	_day=date.day;
}

4.运算符重载

C++为了增强代码的可读性引入了运算符重载，运算符重载是具有特殊函数名的函数，也具有其返回值类型，函数名字以及参数列表，其返回值类型与参数列表与普通的函数类似。
函数名字为：关键字operator后面接需要重载的运算符符号。
函数原型：返回值类型 operator操作符(参数列表)
注意：

  • 不能通过连接其他符号来创建新的操作符：比如operator@。
  • 重载操作符必须有一个类类型或者枚举类型的操作数。
  • 用于内置类型的操作符，其含义不能改变，例如：内置的整型+，不 能改变其含义。
  • 作为类成员的重载函数时，其形参看起来比操作数数目少1成员函数的
    操作符有一个默认的形参this，限定为第一个形参。
  • .* 、:: 、sizeof 、?: 、. 注意以上5个运算符不能重载。

5. 赋值运算符重载

class Date
{
public :
	Date(int year = 1900, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	Date (const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	Date& operator=(const Date& d)
	{
		if(this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year ;
	int _month ;
	int _day ;
};

赋值运算符主要有四点：

  1. 参数类型
  2. 返回值
  3. 检测是否自己给自己赋值
  4. 返回*this

一个类如果没有显式定义赋值运算符重载，编译器也会生成一个，完成对象按字节序的值拷贝。

6.取地址及const修饰的取地址操作符重载

这两个默认成员函数一般不用重新定义 ，编译器默认会生成

class Date
{
public :
	Date* operator&()
	{
		return this ;
	}
	const Date* operator&()const
	{
		return this ;
	}
private :
	int _year ; // 年
	int _month ; // 月
	int _day ; // 日
};

这两个运算符一般不需要重载，使用编译器生成的默认取地址的重载即可，只有特殊情况，才需要重载，比如想让别人获取到指定的内容。
结论：
5. const对象不能调用非const成员函数
6. 非const对象可以调用const成员函数
7. const成员函数内不能调用其它的非const成员函数
8. 非const成员函数内可以调用其它的const成员函数

总结6个默认成员函数

在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值