一切我们研究的事物，都可以叫做对象。对象具有状态，操作和行为。通常用一个数值来描述对象的状态。对象的操作用于改变对象的状态。对象和对象的操作就是对象的行为。
具有相同或相似性质的对象的抽象就是类。类有属性和操作。通常用数据结构来描述类的属性。类的属性是对对象状态的抽象。用用户名和实现操作的方法来描述类的操作。类的操作是对象行为的抽象。
1 类
C++中定义类的形式为
class 类的名字
{
public:
公有的数据成员定义
公有的成员函数
private:
私有的数据成员定义
私有的成员函数
};
类是由类头和类体两部分组成。类头就是class + 类名。类体就是花括号中的内容。类体一般包含两部分
- 数据成员
指定类对象的内部表示 - 成员函数
指定该类的操作
类的成员有三种不同的访问权限
- 公有（public）
成员可以在类外访问 - 私有（private）
成员只能被该类内的成员函数访问 - 保护（protected）
成员只能被该类的成员函数或派生类的成员函数访问
数据成员通常是私有的。成员函数通常有一部分是公有的，一部分是私有的。公有的成员函数可在类外被访问，也称为类的接口。
类的成员函数通常在类外定义。类外定义类的成员函数的一般形式如下
返回类型 类名::函数名(输入参数)
在类外定义的成员函数，仍然需要在类内声明。
2 对象
类是用户定义的数据类型，不占内存单元。类存在于静态的程序中（即运行前的程序），而动态的面向对象程序（即运行中的程序）则由对象构成。程序的执行是通过对象之间相互发送消息来实现的，对象是类的实例（占内存单元）。
2.1 创建对象
对象与变量类似。在所有函数之外创建的对象，称为全局对象。在函数内创建的对象，称为局部对象。全局对象和局部对象的生存周期与全局变量和局部变量相同。通过new操作创建的对象，称为动态对象。动态对象需要用delete操作撤销。
以下内容来自C知道
new和delete是动态内存分配和释放的关键字。new可以创建一个指定类型的对象，并返回该对象的指针；delete可以释放一个指定的对象，并将该对象占用的内存返回给系统。这两个关键字经常被用来创建和删除对象。在使用new和delete的时候需要注意内存泄露和指针悬挂的问题。同时，在使用new动态分配内存时，还需要保证分配的内存空间不会超出系统的限制，否则会出现内存申请失败的情况。因此，在使用new和delete时需要谨慎考虑，以确保程序能正确地运行。
int* p = new int(5);
delete p;
2.2 对象的操作
对于创建的一个对象，需要通过调用对象类中定义的成员函数来对它进行操作。操作对象的一般形式为
对象名.成员函数名(实参表)
或者
指向对象的指针->成员函数名(实参表)
这里通过一个简单的例子来展示一下对象的操作
#include<iostream>
using namespace std;
class temp
{
public:
int a; // 数据成员
// 成员函数
void function1 ()
{
cout << "function1 is called!" << endl;
}
// 类外定义的成员函数的声明
void function2 ();
};
// 类外成员函数
void temp::function2 ()
{
cout << "function2 is called!" << endl;
}
int main()
{
temp i; // 创建一个temp类的局部对象
temp* p;
p = new temp; // 创建一个temp类的动态对象，用p指向该对象
// 调用成员函数对创建的对象进行操作
i.function1();
// 调用成员函数对创建的对象进行操作
p->function2();
delete p;
return 0;
}
输出结果为
function1 is called!
function2 is called!
2.3 构造函数
程序运行时创建的每个对象只有在初始化后才能使用。对C++中定义了一种特殊的初始化函数，称之为构造函数。当对象被创建时，构造函数自动被调用。构造函数的名字与类名相同，它没有返回类型和返回值。当对象创建时，会自动调用构造函数进行初始化。当未定义构造函数，但是编译器需要嗲用构造函数时，编译器会自动生成默认的构造函数来初始化对象。因此，并不是所有的类都需要构造函数。这里看一个简单的例子
#include<iostream>
using namespace std;
class temp
{
public:
int a; // 数据成员
// 构造函数
temp ()
{
a = 10;
}
// 成员函数
void function1 ()
{
cout << a << endl;
}
};
int main()
{
temp i; // 创建一个temp类的局部对象
// 调用成员函数对创建的对象进行操作
i.function1();
return 0;
}
输出结果为10。如果不定义构造函数，输出结果为0。需要注意的是，对构造函数的调用是对象创建过程的一部分，对象创建之后就不能再调用构造函数了。
2.4 析构函数
当对象销毁时，会自动调用析构函数进行一些清理工作。析构函数也与类同名，但在名字前有一个“~”，析构函数也没有返回类型和返回值。析构函数不带参数，不能重载。析构函数的调用顺序与构造函数的调用顺序相反。下面通过一个简单的例子来理解一下
#include<iostream>
using namespace std;
class temp
{
public:
// 构造函数
temp ()
{
cout << "构造函数被调用" << endl;
}
// 析构函数
~temp()
{
cout << "析构函数被调用" << endl;
}
};
int main()
{
temp i,j; // 创建temp类的局部对象
cout << "main函数" << endl;
return 0;
}
输出结果为
3 静态成员
定义静态成员的方法比较简单，直选要在成员变量和成员函数前增加一个“static”即可。静态成员有以下特点
- 静态成员被类的所有对象共享。不会随着对象的创建而被多次创建和初始化。
- 静态函数仅能访问静态的数据成员。
- 静态成员变量只能在类外进行初始化。
- 公有的静态成员可以通过“类名::成员函数(输入参数)/成员变量”进行调用和访问。
#include<iostream>
using namespace std;
class temp
{
public:
int a; // 数据成员
// 构造函数
temp ()
{
a = 10;
}
};
int main()
{
// 通过对象访问成员变量
temp i; // 定义一个temp类的对象
cout << "a=" << i.a << endl;
return 0;
}
如果a是静态成员，还可以通过“类名::成员变量名”访问成员变量。
#include<iostream>
using namespace std;
class temp
{
public:
static int a; // 数据成员
};
// 静态变量只能在类外进行初始化
int temp::a = 10;
int main()
{
// 通过对象访问成员变量
temp i; // 定义一个temp类的对象
cout << "a=" << i.a << endl;
// 通过类名访问成员变量
cout << "a=" << temp::a << endl;
return 0;
}
4 this指针
在介绍this指针前，先看一个简单的小例子
#include<iostream>
using namespace std;
class temp
{
public:
void function (int m)
{
a = m;
cout << "a=" << a << endl;
}
private:
int a;
int b;
};
int main()
{
temp i; // 定义一个类temp的对象
i.function(1);
return 0;
}
输出结果为
a=1
现在考虑一个问题，对于类函数function，它是怎么知道是对哪一个对象进行操作呢？这就需要this指针来告诉它。
- this指针指向当前对象，可以访问当前对象的所有成员变量。包括private、protected、public。
- this指针是const指针，不可以被赋值和修改。
- this指针只有在类的非静态成员函数中有定义，仅在类的成员函数中访问。
实际上面的函数可以写成
void function (temp* const this,int m)
{
this -> a = m;
}
5 友元
C++中为了保护数据，使用private访问控制，来限制类外对类内数据成员的访问。C++中可以指定某个全局函数、某个其他类或某个其他类的成员函数来直接访问另一个类的私有 (private) 和保护 (protected) 成员，它们分别称为友元函数、友元类和友元类函数，通称为友元。友元的作用是提高程序设计的灵活性，是数据保护和对数据的存取效率之间的一种折中方案。