C++ 类和对象示例
本杰明·沃克
什么是类？
A C++ 类将数据和用于操作数据的方法合二为一。类还决定了对象的形式。类中包含的数据和方法称为类成员。类是用户定义的数据类型。要访问类成员，我们使用类的实例。您可以将类视为对象的蓝图。
类是房屋的原型。它显示了门、窗、地板等的位置和大小。根据这些描述，我们可以建造一栋房子。房子成为对象。可以从原型创建许多房屋。同样，也可以从一个类创建许多对象。
在上图中，我们有一个房屋原型。从这个原型开始，我们创建了两栋具有不同特征的房屋。
类别声明
在 C+ 中，使用 class 关键字来定义类。该关键字后面应跟类名。类主体随后添加在花括号 { } 之间。
句法
class class-name
{
// data
// functions
};
- 类名是分配给类的名称。
- 数据是类的数据，通常声明为变量。
- 这些函数是类函数。
私有和公共关键字
你一定遇到过这两个关键字。它们是访问修饰符。
- 私人：
当使用 private 关键字定义函数或类时，该函数或类即变为私有函数或类。此类函数或类只能在类内访问。
- 上市：
另一方面，public 关键字使数据/函数公开。它们可以从类外部访问。
对象定义
对象是由类创建的。类对象的声明方式与变量的声明方式类似。必须以类名开头，后跟对象名。类类型的对象。
句法
class-name object-name;
- 类名是要创建对象的类的名称。
- 对象名称是要分配给新对象的名称。
从类创建对象的过程称为实例化。
访问数据成员
要访问类的公共成员，我们使用 (.) 点运算符。这些成员标有公共访问修饰符。
例子1
#include <iostream>
using namespace std;
class Phone {
public:
double cost;
int slots;
};
int main() {
Phone Y6;
Phone Y7;
Y6.cost = 100.0;
Y6.slots = 2;
Y7.cost = 200.0;
Y7.slots = 2;
cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
cout << "Cost of Huawei Y7 : " << Y7.cost << endl;
cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;
return 0;
}
输出：
以下是代码截图：
代码说明:
- 在我们的代码中包含 iostream 头文件以便使用其功能。
- 在我们的代码中包含 std 命名空间以便使用它的类而不调用它。
- 声明一个名为 Phone 的类。
- 使用公共访问修饰符将我们即将创建的变量标记为可公开访问。
- 声明双精度数据类型的变量成本。
- 声明一个名为 slots 的整型变量。
- 课堂主体结束。
- 调用main()函数。程序逻辑应添加到其主体内。
- 创建一个名为 Y6 且类型为 Phone 的对象。这称为实例化。
- 创建一个名为 Y7 且类型为 Phone 的对象。这称为实例化。
- 使用对象 Y6 访问 Phone 类的变量/成员成本。该值设置为 100.0。Y6 的成本现在设置为 100.0。
- 使用对象 Y6 访问 Phone 类的变量/成员槽。值设置为 2。Y6 的槽现在设置为 2。
- 使用对象 Y7 访问 Phone 类的变量/成员成本。该值设置为 200.0。Y7 的成本现在设置为 200.0。
- 使用对象 Y7 访问 Phone 类的变量/成员槽。值设置为 2。Y7 的槽现在设置为 2。
- 将 Y6 的成本与其他文本一起打印在控制台上。
- 将 Y7 的成本与其他文本一起打印在控制台上。
- 与其他文本一起打印 Y6 的插槽数量。
- 与其他文本一起打印 Y7 的插槽数量。
- 程序成功完成后必须返回一个值。
- main() 函数体结束。
什么是私人课程？
标记为私有的类成员只能由类内定义的函数访问。类外定义的任何对象或函数都不能直接访问此类成员。私有类成员只能由成员和友元函数访问。
什么是受保护类别？
标记为 protected 的类成员比标记为 private 的类成员有优势。它们可以由其定义类中的函数访问。此外，它们还可以从派生类访问。
例子2
#include <iostream>
using namespace std;
class ClassA {
public:
void set_a(int val);
int get_a(void);
private:
int a;
};
int ClassA::get_a(void) {
return a;
}
void ClassA::set_a(int val) {
a = val;
}
int main() {
ClassA a;
a.set_a(20);
cout << "Value of a is: " << a.get_a();
return 0;
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件以使用其功能。
- 在我们的代码中包含 std 命名空间，以便使用它的类而不调用它。
- 创建一个名为 ClassA 的类。
- 使用公共访问修饰符将要创建的类成员标记为可公开访问。
- 创建名为 set_a() 的函数，该函数接受一个整数值 val。
- 创建一个名为get_a()的函数。
- 使用私有访问修饰符将要创建的类成员标记为私有可访问。
- 声明一个名为a的整型变量。
- 课堂主体结束。
- 使用类名和范围解析运算符来访问函数 get_a()。我们想要定义该函数在调用时执行的操作。
- 函数 get_a() 在调用时应该返回变量 a 的值。
- 函数 get_a() 定义结束。
- 使用类名和范围解析运算符来访问函数 set_a()。我们想要定义该函数在调用时执行的操作。
- 将变量val的值赋给变量a。
- 函数 set_a() 定义结束。
- 调用 main() 函数。程序逻辑应添加在此函数主体内。
- 创建 ClassA 的一个实例并赋予其名称 a。
- 使用上述类实例和函数 set_a() 将值 20 分配给变量 a。
- 在控制台上打印一些文本以及变量 a 的值。变量 a 的值是通过调用 get_a() 函数获取的。
- 程序成功完成后必须返回值。
- 函数 main() 主体结束。
例子3
#include <iostream>
using namespace std;
class ParentClass {
protected:
int value;
};
class ChildClass : public ParentClass {
public:
void setId(int x) {
value = x;
}
void displayValue() {
cout << "Value is: " << value << endl;
}
};
int main() {
ChildClass c;
c.setId(21);
c.displayValue();
return 0;
}
输出：
以下是代码截图：
代码说明：
- 在我们的代码中包含 iostream 头文件以使用其功能。
- 在我们的代码中包含 std 命名空间，以便使用它的类而不调用它。
- 创建一个名为 ParentClass 的类。
- 使用受保护的访问修饰符将要创建的类成员标记为受保护的。
- 创建一个名为value的整型变量。
- 课堂主体结束。
- 创建一个名为 ChildClass 的新类，继承 ParentClass。
- 使用受保护的访问修饰符将要创建的类成员标记为子类可访问。
- 创建名为 setId() 的函数，该函数接受一个整数值 x。
- 将变量 x 的值分配给变量值。
- 函数 setId() 定义结束。
- 创建一个名为displayValue（）的函数。
- 将名为 value 的变量的值与其他文本一起打印在控制台上。
- 函数 displayValue() 主体结束。
- ChildClass 类的主体结束。
- 调用 main() 函数。程序逻辑应添加在此函数主体内。
- 创建 ChildClass 的一个实例并将其命名为 c。
- 使用上述类实例和函数 setId() 将值 21 分配给变量 x。
- 使用上述类实例调用名为displayValue（）的函数。
- 程序成功完成后必须返回值。
- 函数 main() 主体结束。
类成员函数
函数帮助我们操作数据。类成员函数可以用两种方式定义：
- 在类定义中
- 类定义之外
如果要在类定义之外定义函数，则必须使用范围解析运算符 (::)。这应该伴随类和函数名称。
例子2
#include <iostream>
#include <string>
using namespace std;
class Guru99
{
public:
string tutorial_name;
int id;
void printname();
void printid()
{
cout << "Tutorial id is: "<< id;
}
};
void Guru99::printname()
{
cout << "Tutorial name is: " << tutorial_name;
}
int main() {
Guru99 guru99;
guru99.tutorial_name = "C++";
guru99.id = 1001;
guru99.printname();
cout << endl;
guru99.printid();
return 0;
}
输出：
以下是代码截图：
代码说明：
- 在我们的程序中包含iostream头文件以使用其功能。
- 在我们的程序中包含字符串头文件以使用其功能。
- 在我们的代码中包含 std 命名空间，以便使用它的类而不调用它。
- 创建一个名为 Guru99 的类。
- 使用公共访问修饰符将我们即将创建的类成员标记为可公开访问。
- 创建一个名为tutorial_name的字符串变量。
- 创建一个名为id的整型变量。
- 创建一个名为 printname() 的函数。此函数未在类定义中定义。
- 创建一个名为printed()的函数。此函数在类定义中定义。其主体已添加到类定义中。
- 在控制台上打印变量 id 的值以及其他文本。请注意，这已添加到 printid() 函数主体中。它仅在调用 printid() 函数时执行。
- printid() 函数体结束。
- Guru99 类主体结束。
- 函数 printname() 定义的开始。
- 在控制台上打印变量 tutorial_name 的值以及其他文本。请注意，这已添加到 printname() 函数主体中。它仅在调用 printname() 函数时执行。
- printname() 函数定义结束。
- 调用 main() 函数。程序逻辑应添加在此函数主体内。
- 创建 Guru99 类的实例并将其命名为 guru99。
- 使用上述实例来分配值 C++ 到变量 tutorial_name。
- 使用guru99实例将值1001分配给变量id。
- 使用实例 guru99 调用函数 printname() 。
- 调用end（结束行）命令在控制台上打印一个新的空白行。
- 使用实例guru99调用函数printid()。
- 程序成功完成后必须返回值。
- main() 函数体结束。
构造函数和析构函数
什么是构造函数？
构造函数是用于初始化对象的特殊函数。 C++ 编译器 创建对象时会调用构造函数。构造函数用于为类成员赋值。当然，这是在为它们分配了一些内存空间之后。
什么是析构函数？
另一方面，析构函数有助于销毁类对象。
构造函数名称必须与类名相似。构造函数没有返回类型。
构造函数可以在类体内部或外部定义。如果在类体外部定义，则应使用类名和作用域解析运算符 (::) 来定义。
例子3
#include <iostream>
using namespace std;
class ClassA {
public:
ClassA() {
cout << "Class constructor called"<<endl;
}
~ClassA() {
cout << "Class destructor called"<<endl;
}
};
int main() {
ClassA a;
int p = 1;
if (p) {
ClassA b;
}
}
输出：
以下是代码截图：
代码说明：
- 将 iostream 头文件包含到代码中以使用其功能。
- 在我们的代码中包含 std 命名空间，以便使用它的类而不调用它。
- 创建一个名为 ClassA 的类。
- 使用公共访问修饰符将我们即将创建的成员标记为可公开访问。
- 为该类创建一个构造函数。
- 调用构造函数时在控制台上打印的文本。endl 是 C++ 关键字，表示结束行。它将鼠标光标移动到下一行。
- 类构造函数主体的结束。
- 为该类创建一个析构函数。
- 调用析构函数时在控制台上打印的文本。endl 是 C++ 关键字，表示结束行。它将鼠标光标移动到下一行。
- 析构函数主体的结束。
- 课堂主体结束。
- 调用 main() 函数。程序逻辑应添加在此函数主体内。
- 创建一个类对象并赋予其名称a。构造函数将被调用。
- 创建一个名为 p 的整型变量并赋值 1。
- 使用变量 p 创建一个 if 语句块。
- 创建一个类对象并将其命名为b。析构函数将被调用。
- if 语句主体结束。
- main() 函数体结束。
结语
- C++ 是面向对象的。
- 课程构成了 C++ 这使得它面向对象。
- A C++ 类将数据和操作数据的方法合二为一。
- 类是对象的蓝图。
- 类别决定对象的形式。
- 类中包含的数据和方法称为类成员。
- 要访问类成员，您应该使用该类的实例。
- 要创建一个类，我们使用 class 关键字。
- 类成员函数可以在类内部或外部定义。
