C++基础教程面向对象（学习笔记2）

1.1类和类成员

前面发了两篇似乎是无关紧要的，但是我希望还是可以看看，毕竟介绍了我们接下来要学的内容以及我的一些中肯的建议。

虽然C ++提供了许多基本数据类型（例如char，int，long，float，double等等），这些类型通常足以解决相对简单的问题，但仅使用这些类型解决复杂问题可能很困难。C ++的一个更有用的功能是能够定义自己的数据类型，更好地对应于正在解决的问题。您已经了解了枚举类型和结构如何用于创建自己的自定义数据类型。

以下是用于保存日期的结构体示例：

struct DateStruct
{
    int year;
    int month;
    int day;
};

枚举类型和仅数据结构（仅包含变量的结构）代表传统的非面向对象编程世界，因为它们只能保存数据。在C ++ 11中，我们可以按如下方式创建和初始化此结构：

DateStruct today { 2020, 10, 14 }; // 用统一初始化的方式初始化

现在，如果我们想要将日期打印到屏幕上（我们可能想要做很多事情），编写一个函数来执行此操作是有意义的。这是一个完整的程序：

#include <iostream>
 
struct DateStruct
{
    int year;
    int month;
    int day;
};
 
void print(DateStruct &date)
{
    std::cout << date.year << "/" << date.month << "/" << date.day;
}
 
int main()
{
    DateStruct today { 2020, 10, 14 }; //用统一初始化的方式初始化
 
    today.day = 16; // 使用成员变量选择符号来选择你的结构成员变量
    print(today);
 
    return 0;
}

该程序打印：

2020年10月16日

类

在面向对象编程的世界中，我们经常希望我们的类型不仅可以保存数据，还可以提供与数据一起使用的函数。在C ++中，这通常通过class关键字完成。使用class关键字定义一个名为class的新用户定义类型。

在C ++中，类非常类似于仅数据结构，除了类提供更多的功能和灵活性。实际上，以下结构和类实际上是相同的：

struct DateStruct
{
    int year;
    int month;
    int day;
};
 
class DateClass
{
public:
    int m_year;
    int m_month;
    int m_day;
};

请注意，唯一重要的区别是类中的关键字public。我们将在下一课中讨论此关键字的功能。
就像结构声明一样，类声明不会声明任何内存。它只定义了类的外观。
警告：就像使用结构一样，在C ++中最简单的错误之一是在类声明结束时忘记分号。这将导致下一行代码出现编译器错误。像Visual Studio 2013这样的现代编译器会向您显示您可能忘记了分号，但较旧或较不复杂的编译器（例如：VC++6.0）可能没有，这可能使实际错误难以找到。
就像使用结构一样，要使用类，必须声明该类类型的变量：

DateClass today { 2020, 10, 14 }; // 声明一个 DateClass的类

在C ++中，当我们定义一个类的变量时，我们称它为实例化类。变量本身称为类的实例。类类型的变量也称为对象。就像定义内置类型的变量（例如int x，double y等等）为该变量分配内存一样，实例化一个对象（例如上述DateClass）为该对象分配内存。

成员功能

除了保存数据外，类还可以包含函数！（我认为这是C++扩展的最棒的部分）在类中定义的函数称为成员函数（或有时称为方法）。可以在类定义的内部或外部定义成员函数。我们现在将在类中定义它们（为简单起见），并展示如何在类之外定义它们。
这是我们的Date类，其中包含用于打印日期的成员函数：

class DateClass
{
public:
    int m_year;
    int m_month;
    int m_day;
 
    void print() // 定义一个名为： print()
    {
        std::cout << m_year << "/" << m_month << "/" << m_day;
    }
};

就像结构的成员一样，使用成员选择器运算符（.）访问类的成员（变量和函数）：

#include

class DateClass
{
public:
int m_year;
int m_month;
int m_day;

void print()
{
    std::cout << m_year << "/" << m_month << "/" << m_day;
}

};

int main()
{
DateClass today { 2020, 10, 14 };

today.m_day = 16; // 用选择成员操作符来选择类中的成员变量
today.print(); // 用选择成员操作符来选择类中的成员函数

return 0;

}
这打印：

2020年10月16日
注意这个程序与我们上面编写的struct版本有多相似。

但是，存在一些差异。在上面示例的print（）的DateStruct版本中，我们需要将struct本身作为第一个参数传递给print（）函数。否则，print（）将不知道我们想要使用的DateStruct。然后我们必须明确地在函数内引用这个参数。

成员函数的工作方式略有不同：所有成员函数调用必须与类的对象相关联。当我们调用“today.print（）”时，我们告诉编译器调用与today对象关联的print（）成员函数。

现在让我们再看一下打印成员函数的定义：

    void print() // 定义一个名为： print()的函数
    {
        std::cout << m_year << "/" << m_month << "/" << m_day;
    }

m_year，m_month和m_day实际上是指什么？它们引用相关对象（由调用者确定）。

因此，当我们调用“today.print（）”时，编译器将m_dayas today.m_day，m_monthas today.m_month和m_yearas 解释为today.m_year。如果我们调用“tomorrow.print（）”，m_day则会引用tomorrow.m_day。

以这种方式，关联对象基本上隐式地传递给成员函数。因此，它通常被称为隐式对象。

我们将在本章的后续课程中详细讨论隐式对象传递的工作原理。

关键点在于，对于非成员函数，我们必须将数据传递给要使用的函数。使用成员函数，我们可以假设我们总是有一个类的隐式对象来使用！

使用成员变量的“m_”前缀有助于将成员变量与成员函数内的函数参数或局部变量区分开来。由于几个原因，这很有用。首先，当我们看到带有“m_”前缀的变量的赋值时，我们知道我们正在改变类的状态。其次，与函数中声明的函数参数或局部变量不同，成员变量在类定义中声明。因此，如果我们想知道如何声明带有“m_”前缀的变量，我们知道我们应该查看类定义而不是函数内部。

按照惯例，类名应以大写字母开头。

规则：将您的类命名为以大写字母开头。

这是一个类的另一个例子：

#include <iostream>
#include <string>
 
class Employee
{
public:
    std::string m_name;
    int m_id;
    double m_wage;
 
    // 将员工信息打印到屏幕上
    void print()
    {
        std::cout << "Name: " << m_name <<
                "  Id: " << m_id << 
                "  Wage: $" << m_wage << '\n'; 
    }
};
 
int main()
{
    // Declare two employees
    Employee alex { "Alex", 1, 25.00 };
    Employee joe { "Joe", 2, 22.25 };
 
    // 将员工信息输出到屏幕上
    alex.print();
    joe.print();
 
    return 0;
}

这会产生输出：

姓名：Alex Id：1工资：25美元
姓名：Joe Id：2工资：22.25美元
与普通函数不同，定义成员函数的顺序无关紧要！

关于C ++结构和类的解释：

在C中，结构只能保存数据，并且没有关联的成员函数。在C ++中，在设计类（使用class关键字）之后，Bjarne Stroustrup花了一些时间考虑结构（从C继承）是否应该被赋予相同的功能。在考虑之后，他确定他们应该部分地为两者制定统一的规则。因此，尽管我们使用class关键字编写了上述程序，但我们可以使用struct关键字。

许多开发人员（包括我自己）认为这是不正确的决定，因为它可能导致危险的假设：例如，假设一个类将在自身之后清理是正确的（例如，分配内存的类将在被释放之前释放它（），但假设一个结构将是不安全的。因此，我们建议将struct关键字用于仅数据结构，并使用class关键字来定义需要将数据和函数捆绑在一起的对象。

规则：对仅数据结构使用struct关键字。对具有数据和函数的对象使用class关键字。

您已经在不知情的情况下使用了类

事实证明，C ++标准库中充满了为您的利益而创建的类。std :: string，std :: vector和std :: array都是类类型！因此，当您创建任何这些类型的对象时，您将实例化一个类对象。当你使用这些对象调用一个函数时，你正在调用一个成员函数。

#include <string>
#include <array>
#include <vector>
#include <iostream>
 
int main()
{
    std::string s { "Hello, world!" }; // 初始化一个字符串类的对象
    std::array<int, 3> a { 1, 2, 3 }; // 初始化数组类对象
    std::vector<double> v { 1.1, 2.2, 3.3 }; //初始化向量类对象
 
    std::cout << "length: " << s.length() << '\n'; // 调用一个成员函数
 
    return 0;
}

结论：

class关键字允许我们在C ++中创建一个可以包含成员变量和成员函数的自定义类型。类构成了面向对象编程的基础，我们将花费本章的其余部分以及未来的许多章节来探索它们所提供的所有内容！

Quiz time：
题目要求：创建一个名为IntPair的类，它包含两个整数。这个类应该有两个成员变量来保存整数。您还应该创建两个成员函数：一个名为“set”，用于为整数赋值，另一个名为“print”，用于打印变量值。
问题：为什么我们要使用类而不是用结构体？（请先思考，答案在最后）
应执行以下主要功能：

int main()
{
	IntPair p1;
	p1.set(1, 1); // 设置p1的值为 (1, 1)
	
	IntPair p2{ 2, 2 }; //初始化 p2 的值为 (2, 2)
 
	p1.print();
	p2.print();
 
	return 0;
}

并产生输出：
（1,1）
（2,2）

解决方案的代码：

#include <iostream>
 
class IntPair
{
public:
	int m_first;
	int m_second;
	
	void set(int first, int second)
	{
		m_first = first;
		m_second = second;
	}
	void print()
	{
		std::cout << "Pair(" << m_first << ", " << m_second << ")\n";
	}
};
 
int main()
{
	IntPair p1;
	p1.set(1, 1);
	
	IntPair p2{ 2, 2 };
 
	p1.print();
	p2.print();
 
	return 0;
}

为什么我们要为IntPair而不是结构使用类？
回答：该对象包含成员数据和成员函数，因此我们应该使用一个类。我们不应该对具有成员函数的对象使用结构。