参考链接
类
这个其实在前面讲的时候，就已经涉及过类的使用，现在使用文字描述一下。C语言是面向过程的编程，C++是面向对象的过程。类说白了就是用户定义的类型，类中的数据和方法（可以理解为一个个函数）称为类的成员。下面说一下类的使用，类的定义是以class关键字开头，主体是花括号的内容，下面来说明一下：
class 类型
{
public: //public是类成员的属性，即在成员中的作用域，公有成员：类的外部可以访问
数据类型 变量名1;
数据类型 变量名2;
private: //private是类成员的属性，私有成员：类的外部是不可访问的，甚至是不可查看的。只有类和友元函数可以访问私有成员。
数据类型 变量名3;
protected: //几乎与private属性相似，但是它在保护成员派生的类可以访问
数据类型 变量名4;
};通过程序来实例说明：
#include <iostream>
using namespace std;
class Project {
public:
Project(); //构造函数：在对象创建的时候调用，不返回类型，主要对类中成员变量初始化
~Project(); //析构函数：在删除对象的时候调用，主要用于释放资源
int getProjectName() const; //方法
int getProjectTimes() const; //方法
private:
mutable int iTimes;
int iName;
};
Project::Project()
{
iTimes = 0;
}
Project::~Project() {}
int Project::getProjectName() const
{
cout << "天眼工作室" << endl;
iTimes++;
return 1;
}
int Project::getProjectTimes() const
{
return iTimes;
}
int main()
{
Project *project = new Project(); //创建对象
for (int i = 0; i < 5; i++)
{
project->getProjectName();
}
cout << "调用" << project->getProjectTimes() << "次" << endl;
delete project;
getchar();
return 0;
}运行结果
天眼工作室
天眼工作室
天眼工作室
天眼工作室
天眼工作室
调用5次构造函数拷贝
构造函数拷贝可以理解为使用之前构造的同类对象初始化新创建的对象，因为类内部类成员变量很多，不能简单想普通数据类型赋值(int iVar = 10;)。因此，针对这个问题C++创建了构造函数拷贝。常见的构造函数形式：
类名 (const 类名 &obj)
{
/*函数主体*/
}主要有三种使用方式：另一个同类型的对象来初始化新创建的对象、复制对象把它作为参数传递给函数、复制对象并从函数返回这个对象。
实例分析：
#include <iostream>
using namespace std;
class CompareCubeClass
{
public:
CompareCubeClass(int iTmpL, int iTmpW);
~CompareCubeClass();
CompareCubeClass(const CompareCubeClass &obj);
int getCubeLengthInfo();
private:
int *length;
int *width;
};
CompareCubeClass::CompareCubeClass(int iTmpL, int iTmpW)
{
length = new int;
width = new int;
*length = iTmpL;
*width = iTmpW;
cout << "构造函数：*length = " << *length << " *width = " << *width << endl;
}
CompareCubeClass::CompareCubeClass(const CompareCubeClass &obj)
{
length = new int;
width = new int;
*length = *obj.length;
*width = *obj.width;
cout << "拷贝构造函数" ;
cout << "：*length = " << *length << " *width = " << *width << endl;
}
int CompareCubeClass::getCubeLengthInfo()
{
return *length;
}
CompareCubeClass::~CompareCubeClass()
{
}
void display(CompareCubeClass obj)
{
cout << "Length 大小 : " << obj.getCubeLengthInfo() << endl;
}
int main()
{
//方式一：对象引用初始化另一个对象
CompareCubeClass cube1(10, 5);
display(cube1);
//方式二：已有同类对象对新对象赋值
CompareCubeClass cube2 = cube1; //
getchar();
}
运行结果
构造函数：*length = 10 *width = 5
拷贝构造函数：*length = 10 *width = 5
Length 大小 : 10
拷贝构造函数：*length = 10 *width = 5注：如果类中没有声明构造函数拷贝，则编译器会自行定义。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。
友元函数
这里其实就是引入一个关键字friend，声明后的函数和类可以访问类中的private和protect变量。下面我们来实例看一下friend使用方法：
友元函数
class 类名
{
public:
数据类型 变量名;
friend 返回类型 函数名(形式参数);
private:
数据类型 变量名;
}友元类
friend class 类名;实例代码：
#include <iostream>
using namespace std;
//OwnBusiness类
class OwnBusiness
{
public:
OwnBusiness(char* cName);
~OwnBusiness();
friend char* getCompanyName(OwnBusiness company1); //getCompanyName函数时OwnBusiness的友元函数
void printDate(OwnBusiness company1);
friend class Project; //Project类是OwnBusiness的友元类
private:
char* companyName;
int createDate;
};
OwnBusiness::OwnBusiness(char* cName)
{
companyName = cName;
}
void OwnBusiness::printDate(OwnBusiness company1)
{
cout << "创建日期：" << company1.createDate << endl;
}
OwnBusiness::~OwnBusiness(){}
char* getCompanyName(OwnBusiness company1)
{
return company1.companyName;
}
//Project类
class Project
{
public:
Project();
~Project();
void projectPrint(OwnBusiness &tmpBusiness, int iDate)
{
tmpBusiness.createDate = iDate;
}
private:
};
Project::Project(){}
Project::~Project(){}
int main()
{
OwnBusiness *company1 = new OwnBusiness("天眼工作室");
Project *project1 = new Project();
project1->projectPrint(*company1, 2020);
cout << getCompanyName(*company1) << endl;
company1->printDate(*company1);
getchar();
}运行结果
天眼工作室
创建日期：2020注：尽量不要使用友元函数，因为该功能破坏了类之间相互独立的功能。
内联函数
在书写程序中，总会有一些函数会调用比较频繁，即不断的有函数入栈，即函数栈，会造成栈空间或栈内存的大量消耗。因此，针对这个问题C语言创建了inline关键字。这里说明一下，在C++中类的内部默认都是内联函数，但是都只限制一行语句，如果函数体超过一行语句，即使有关键字限制也不会认为是内联函数。下面程序举例：
#include <iostream>
using namespace std;
inline int CompareDataMax(int iTmpVar1, int iTmpVar2) //内联函数
{
return iTmpVar1 > iTmpVar2 ? iTmpVar1 : iTmpVar2;
}
int main()
{
cout << "10与5中的最大值为：" << CompareDataMax(10, 5) << endl;
getchar();
}运行结果
10与5中的最大值为：10this指针
这是每个对象访问自己的地址，则通过this指针实现。因为友元函数不是类，所以没有this用法。
#include <iostream>
using namespace std;
class CompareCubeClass
{
public:
CompareCubeClass(int iTmpL, int iTmpW);
~CompareCubeClass();
char* maxLength(CompareCubeClass tmpCube);
private:
int length;
int width;
};
CompareCubeClass::CompareCubeClass(int iTmpL, int iTmpW)
{
length = iTmpL;
width = iTmpW;
}
char* CompareCubeClass::maxLength(CompareCubeClass tmpCube)
{
return this->length > tmpCube.length ? "cube1" : "cube2";
}
CompareCubeClass::~CompareCubeClass()
{
}
int main()
{
CompareCubeClass cube1(10, 5); //矩形1 长为10，宽为5
CompareCubeClass cube2(1, 5); //矩形2 长为1，宽为5
cout << "长度最大的矩形为：" << cube1.maxLength(cube2) << endl;
getchar();
}运行结果
长度最大的矩形为：cube1类中静态变量
如果函数中声明为静态，就可以把函数和类任何特定的对象独立起来。并且静态变量不能使用this指针进行访问，它的访问方式为类名加::变量进行访问。
#include <iostream>
using namespace std;
class CompareCubeClass
{
public:
static int iCubeTimes; //静态成员
CompareCubeClass(int iTmpL, int iTmpW);
~CompareCubeClass();
char* maxLength(CompareCubeClass tmpCube);
private:
int length;
int width;
};
CompareCubeClass::CompareCubeClass(int iTmpL, int iTmpW)
{
length = iTmpL;
width = iTmpW;
iCubeTimes++;
}
char* CompareCubeClass::maxLength(CompareCubeClass tmpCube)
{
return this->length > tmpCube.length ? "cube1" : "cube2";
}
CompareCubeClass::~CompareCubeClass()
{
}
int CompareCubeClass::iCubeTimes = 0; //初始化静态变量
int main()
{
CompareCubeClass cube1(10, 5); //矩形1 长为10，宽为5
CompareCubeClass cube2(1, 5); //矩形2 长为1，宽为5
cout << "长度最大的矩形为：" << cube1.maxLength(cube2) << endl;
cout << "矩形数量： " << CompareCubeClass::iCubeTimes << endl;
getchar();
}运行结果
长度最大的矩形为：cube1
矩形数量： 2对象
对象是根据类来声明，其实就像变量声明。
类名 变量名; //方式一
类名 *变量名 = new 类名(形式参数); //方式二注：上面程序都已经进行了举例，这里就不在矩实例。
