本文主要是介绍C++类对象的基本概念，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 前言
• 一、类的定义与使用
• • 1、抽象（分析问题首先抽象成类）
  • 2、类的定义与声明
  • 3、类的访问控制符
  • 4、类的实现与使用
  • 5、指针
• 二、对象的初始化和结束处理
• • 1、构造函数
  • 2、析构函数
  • 3、拷贝构造函数
• 三、类的相关概念
• • 1、类类型做函数参数
  • 2、对象数组
  • 3、静态成员
  • 4、常对象与常成员
  • 5、友元
  • 6、类的组合

前言

本文章主要学习c++类与对象的基本概念。根据视频学习
MOOC第八章内容

一、类的定义与使用

1、抽象（分析问题首先抽象成类）

抽象是为了对具体问题进行概括，提炼出这一类对象的公共性质并加以描述的过程：
抽象有数据抽象和行为抽象
数据抽象：描述某类对象的属性和状态
行为抽象：描述某类对象的行为或具有的功能
抽象由封装实现，在C++中，由类实现封装

2、类的定义与声明

类的定义：
class ClassName
{
数据成员；（表达数据抽象）
函数成员；（表达行为抽象）
}

3、类的访问控制符

类内：在类声明之内。
类外：在类声明之外。
为什么使用访问控制符：封装目的是使信息隐蔽，所以不是所有信息都对外可见。
访问控制符有：
public：
公有成员；（类与外部的接口，类内和类外函数都可以访问）
private：
私有成员；（只允许类内函数访问）
protect：
保护成员；（跟私有成员一样）

4、类的实现与使用

易错点：类对象属于类外，所以不可以访问私有数据成员和函数，只能访问公有成员。

类的实现：

class ClocK
{
private:
	int Hour, Minute, Second;
public:
	void SetTime(int h, int m, int s) {
		Hour = h; Minute = m; Second = s;
	}
	void ShowTime(){
		cout << "Current Time:" ;
		cout << Hour << ":" << Minute << ":" << Second<<endl;
	}
};

类的使用：
类是一种数据成员，类的变量称作类的实例，或对象
定义对象的方式：类名 对象名；

访问类成员的方法：

通过对象访问类成员：

• 对象名.公有成员函数名（参数列表）
• 对象名.公有数据成员

通过指针访问类成员：

• 对象的指针->公有成员函数名（参数列表）
• 对象的指针->公有数据成员

int main()
{
	ClocK clock_1, clock_2;
	clock_1.SetTime(9, 5, 25);
	clock_2.SetTime(15, 25, 32);
	clock_1.ShowTime();
	clock_2.ShowTime();
	return 0;
}

5、指针

• 对象指针
  例如：Clock *p
• this指针
  c++为每个非静态成员函数提供了一个this指针
  this指针指向正在被成员函数操作的那个对象
• 对象的引用
  对象应用就是对某类对象定义的一个引用，实质是给被引用对象起一个别名
  定义：对象名 & 对象引用名=被引用对象；
  使用：对象引用名.数据成员名
  或： 对象引用名.成员函数名（形参表）

    ClocK C1(5, 14, 12);
	Clock& Cr = C1;
	Cr.ShowTime();

二、对象的初始化和结束处理

1、构造函数

解决数据成员自动初始化问题

例如：时钟类的构造函数

• 赋值语句方式

ClocK(int h, int m, int s) {
		Hour = h; Minute = m; Second = s;
	}

• 表达式方式

ClocK(int h, int m, int s):Hour(h),Minute(m),Second(s){}

重载构造函数与缺省构造函数

2、析构函数

专门用于处理对象销毁——析构函数

#include<iostream>
using namespace std;
class CString
{
private:
	int len;
	char* buf;
public:
	CString(int n);
	~CString();
	void copy(char* src);
};
CString::CString(int n)
{
	len = n;
	buf = new char[n];
}
void CString::copy(char* src)
{
	strcpy(buf, src);
}
CString::~CString()
{
	delete []buf;
}
void func()
{
	CString obj(64);
	obj.copy("helloword");
}
int main()
{
	func();
	return 0;
}

该类中创建析构函数是为了清理类对象所指的字符空间。

3、拷贝构造函数

目的：构造一模一样的类对象
定义：将自己同类对象的引用作为参数进行构造函数的初始化时，该构造函数为拷贝构造函数。
特点：

1. 是构造函数，系统会自动调用
2. 将一个已经创建好的对象作为参数，根据需要将该对象中的数据成员逐一对应的赋值给新对象。

按例：

#include<iostream>
using namespace std;
class Point
{
private:
	float x, y;
public:
	Point(float a, float b)
	{
		x = a; y = b;
	}
	//拷贝构造函数的构建
	Point(Point& obj)
	{
		x = obj.x;
		y = obj.y;
	}
	void Print() { cout << x << endl; }
};
int main()
{
	Point obj1(5, 15);//调用普通构造函数
	Point obj2(obj1);//调用拷贝构造函数
	Point obj3 = obj1;//调用拷贝构造函数
	obj1.Print();
	obj2.Print();
	obj3.Print();
	return 0;
}

三、类的相关概念

1、类类型做函数参数

类类型做函数参数的三种方式：

1. 对象本身做函数参数：一般调用缺省的拷贝构造函数。（会有大量的类对象的定义，效率低）
2. 对象的引用做函数参数：只有一次空间分配，效率高，推荐使用。
3. 对象指针作为参数

2、对象数组

数组的初始化：调用构造函数进行初始化

3、静态成员

关键字：static
分类：

1. 静态数据成员：在类内进行定义，在类外进行初始化
   特点是属于类，不属于类对象，只有一个空间。在类外访问需使用类作用域符::。类对象不存在时，也可以访问。

2. 静态成员函数：也属于类，没有this指针。

4、常对象与常成员

关键字：const

1. 常对象：不能被修改且不能访问非常成员函数
2. 常数据成员：只能通过初始化列表来获得初值，静态常成员函数只能在类外进行初始化
3. 常成员函数：在形参列表后加const关键字，不能更改数据成员，可以被非常对象使用

5、友元

关键词：friend

1. 友元函数：可以访问该类对象的私有成员，可以在类内任何地方声明，但不属于类，因此没有this指针
2. 友元类：友元类可访问该类的所有成员
3. 将成员函数声明为另一个类的友元：在函数类型后加上 类名:: ，前面使用friend关键字
4. 性质：不具备传递性和对称性

6、类的组合

定义：一个类对象作为另一个类的成员，成员对象为子对象，用初始化列表方式初始子对象

这篇关于C++类对象的基本概念的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！