C++—类和对象

一切我们研究的事物，都可以叫做对象。对象具有状态，操作和行为。通常用一个数值来描述对象的状态。对象的操作用于改变对象的状态。对象和对象的操作就是对象的行为。

具有相同或相似性质的对象的抽象就是类。类有属性和操作。通常用数据结构来描述类的属性。类的属性是对对象状态的抽象。用用户名和实现操作的方法来描述类的操作。类的操作是对象行为的抽象。

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

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

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

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

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

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

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) 成员，它们分别称为友元函数、友元类和友元类函数，通称为友元。友元的作用是提高程序设计的灵活性，是数据保护和对数据的存取效率之间的一种折中方案。