C++——类和对象（1）

1. 面向对象和面向过程对比

        当涉及到编程范式时，两个主要的方法是面向对象编程（Object-Oriented Programming，OOP）和面向过程编程（Procedural Programming）。这两种编程范式在解决问题和组织代码时有着不同的方法和理念。

1.1 思想方式

• 面向对象编程（OOP）：将问题分解为一组相互关联的对象，对象可以包含数据（属性）和操作数据的方法（行为）。强调对象之间的交互和消息传递，更贴近人类认知和现实世界的模型。

• 面向过程编程：将问题分解为一系列的步骤或过程，强调按照顺序执行这些步骤来解决问题。更加直接，类似于指令式的编程。

1.2 代码组织方式

• 面向对象编程（OOP）：代码组织成一组对象，对象之间通过消息传递进行交互。每个对象负责自己的数据和行为，对象之间的关系和交互通过类的定义来描述。

• 面向过程编程：代码组织成一系列的过程或函数，按照执行顺序依次调用这些过程来完成任务。数据在过程之间传递，强调函数的调用和返回值。

---

2. 类的引入

        C语言结构体中只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。

例如，在数据结构实现栈的时候：

#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
using namespace std;


struct Stack
{
	int* _a;
	int _top;
	int _capacity;

	void Init()
	{
		_a = nullptr;
		_capacity = 0;
		_top = 0;
	}
	void CheckCapacity()
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity == 0 ? 4 : _capacity * 2;
			int* tmp = (int*)realloc(_a, sizeof(int) * newcapacity);
			if (tmp == nullptr)
			{
				perror("realloc error!");
				exit(-1);
			}
			_a = tmp;
			_capacity = newcapacity;
		}
	}
	void Push(int x)
	{
		CheckCapacity();
		_a[_top++] = x;
	}
	void Pop()
	{
		assert(_top > 0);
		_top--;
	}
	int Top()
	{
		return _a[_top - 1];
	}
	bool Empty()
	{
		return _top == 0;
	}
	void Print()
	{
		while (!Empty())
		{
			cout << _a[_top - 1] << endl;
			Pop();
		}
	}
};

int main()
{
	Stack st;
	st.Init();
	st.Push(1);
	st.Push(2);
	st.Push(3);
	st.Push(4);
	st.Push(5);
	st.Push(6);
	st.Push(7);
	st.Push(8);
	st.Push(9);
	st.Print();
	return 0;
}

在C++中更喜欢用class来代替struct.

---

3. 类的定义

定义方式：

class className
{
	// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

        类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

例如：

class Date
{
	int _year;
	int _month;
	int _day;

	void func()
	{
		cout << "Date func()" << endl;
	}
};

3.1 类定义的两种方式

3.1.1 声明定义放一起

class Date
{
	int _year;
	int _month;
	int _day;

	void func()
	{
		cout << "Date func()" << endl;
	}
};


int main()
{
	Date d1;
	d1.func();
}

3.1.2 声明定义分离

//test.h
#pragma once
#define  _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
using namespace std;

class Date
{
	int _year;
	int _month;
	int _day;
// 访问修饰限定符，下文有解释
public:
	void func();
};

//test.cpp
void Date::func()
{
	cout << "Date func()" << endl;
}

int main()
{
	Date d1;
	d1.func();
}

---

4. 类的访问限定符以及封装

4.1 访问修饰限定符

• C++实现封装的方式：将成员变量和成员函数放在类中，通过访问修饰限定符来限制用户可访问的接口；
• protected和private只能在类中可以访问，除了类不可访问；
• public在类中和类外都可访问；
• 访问修饰限定符的限定范围是从此限定符开始，到下个限定符出现之前结束，如果没出现下一个，则到 “}” 结束；
• class 默认的限定符是 private ，而struct 默认的是 public。

 

• 一般情况下，成员变量限定符规定为 private；
• 成员函数的限定符规定为 public。

4.2 封装

        封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。
        封装本质上是一种管理，让用户更方便使用类。比如：对于电脑这样一个复杂的设备，提供给用户的就只有开关机键、通过键盘输入，显示器，USB插孔等，让用户和计算机进行交互，完成日常事务。但实际上电脑真正工作的却是CPU、显卡、内存等一些硬件元件。

---

5. 类的实例化

类的实例化就是用类创建一个对象，简单的讲就是用类这个类型创建一个变量：

class Person
{
public:
	int _age;
	const char* _sex;
	const char* _name;
	void showInfo()
	{
		cout << "名字是：" << _sex << " 年龄是：" << _age << " 性别是："
			<< _sex << endl;
	}
};

int main()
{
	Person p1;
	p1._age = 18;
	p1._name = "张三";
	p1._sex = "男";
	p1.showInfo();
}

---

6. 类对象模型

6.1 如何计算类对象大小

class Date
{
private:
	int _year;
	int _month;
	int _day;

public:
	void func()
	{
		cout << "Date func()" << endl;
	}
};

        注意这里的成员变量只是声明，而不是定义，定义是要开辟空间的，而这里没有开辟空间，只有在实例化的时候才会定义，例如以下就会报错：

class Date
{
	int _year;
	int _month;
	int _day;

	void func()
	{
		cout << "Date func()" << endl;
	}
};


int main()
{
	Date::_year++;
}

6.2 类对象的存储方式

        类对象的存储，每次实例化都会保存成员变量，而成员函数则放在公共的代码段，为什么呢？

        因为每次调用的函数实现方法都一样，如果每次实例化的时候都要保存一份，那就太浪费空间了，然而成员变量每一次都可能不一样，因此要保存成员变量。

        在编译的过程中，如果出现这个函数的定义，在链接过程中就会call这个函数的地址，如果编译过程中没找到这个函数的定义，那就会在连接过程中把所有的目标文件的符号表合成，寻找其地址。

6.3 内存对齐

实际上类对象的大小也遵循内存对齐的方式：

1. 第一个成员在与结构体偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。VS中默认的对齐数为8
3. 结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍。

注意如果一个类没有成员变量和成员函数或者只有成员函数，那么这个类实例化出来的对象的大小是1byte。

---

7. this指针

7.1 this指针的引出

class Date
{
public:
    void Init(int year, int month, int day)
{
    _year = year;
    _month = month;
    _day = day;
}
void Print()
{
    cout <<_year<< "-" <<_month << "-"<< _day <<endl;
}
private:
    int _year; // 年
    int _month; // 月
    int _day; // 日
};
int main()
{
    Date d1, d2;
    d1.Init(2022,1,11);
    d2.Init(2022, 1, 12);
    d1.Print();
    d2.Print();
    return 0;
}

对于上述类，有这样的一个问题：

• Date类中有 Init 与 Print 两个成员函数，函数体中没有关于不同对象的区分，那当d1调用 Init 函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢？
• C++中通过引入this指针解决该问题，即：C++编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量”的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

7.2 this 指针特性

1.  this指针的类型：类类型* const，即成员函数中，不能给this指针赋值。
2.  只能在“成员函数”的内部使用
3.  this指针本质上是“成员函数”的形参，当对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4.  this指针是“成员函数”第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

 图解：

 

// 1.下面程序编译运行结果是？正常运行
class A
{

public:
    void Print()
    {
    cout << "Print()" << endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->Print(); // 这里虽然看似对空指针解引用，但实际上Print()函数存放在代码段中
                // 不在栈中因此不用找到p所指向的那块区域，不用解引用
    return 0;
}

// 1.下面程序编译运行结果是？ 运行崩溃 
class A
{
public:
    void PrintA()
    {
    cout<<_a<<endl;
    }
private:
    int _a;
};
int main()
{
    A* p = nullptr;
    p->PrintA(); //这里虽然看似一样，但是在Print()中，要对_a进行访问，
                 //而_a应该在栈上，要对p解引用，所以运行崩溃
    return 0;
}