带有示例的 C++ 类和对象

什么是类？

C++ 类将数据和用于操作数据的方法合二为一。类也决定了对象的形式。类中包含的数据和方法称为类成员。类是用户定义的数据类型。要访问类成员，我们使用类的实例。您可以将类视为对象的蓝图。

一个类是一个房子的原型。它显示了门、窗、地板等的位置和大小。根据这些描述，我们可以建造一座房子。房子变成了对象。可以从原型创建许多房屋。此外，可以从一个类中创建许多对象。

在上图中，我们有一个单独的房屋原型。从这个原型中，我们创建了两个具有不同特征的房子。

在本教程中，您将学习：

什么是类？
类示例
私人和公共关键字
对象定义
访问数据成员
类成员函数
构造函数和析构函数

类声明

在 C+ 中，类是使用 class 关键字定义的。这应该跟类名。然后在花括号 { } 之间添加类主体。

语法：

class class-name
   {
   // data
   // functions
   };

类名是分配给类的名称。
数据是类的数据，通常声明为变量。
函数是类函数。

私人和公共关键字

您一定遇到过这两个关键字。它们是访问修饰符。

私人：

当 private 关键字用于定义函数或类时，它就变成了私有的。这些只能从类中访问。

公开：

另一方面，public 关键字使数据/函数公开。这些可以从课堂外访问。

对象定义

对象是从类创建的。类对象的声明方式与声明变量的方式类似。类名必须以对象名开头。类类型的对象。

语法：

class-name object-name;

类名是要从中创建对象的类的名称。
object-name 是分配给新对象的名称。

从类创建对象的过程称为实例化。

访问数据成员

要访问类的公共成员，我们使用 (.)dot 运算符。这些是用公共访问修饰符标记的成员。

示例 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 的类。
使用 public 访问修饰符将我们即将创建的变量标记为可公开访问。
声明双精度数据类型的可变成本。
声明一个名为 slot 的整数变量。
类主体结束。
调用 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() 函数体结束。

什么是私有类？

标记为私有的类成员只能由该类中定义的函数访问。在类之外定义的任何对象或函数都不能直接访问这些成员。私有类成员只能由成员函数和友元函数访问。

什么是受保护的类？

标记为受保护的类成员比标记为私有的类成员具有优势。它们可以被它们定义的类中的函数访问。此外，它们可以从派生类中访问。

示例 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 的类。
使用 public 访问修饰符将要创建的类成员标记为可公开访问。
创建一个名为 set_a() 的函数，它接受一个整数值 val。
创建一个名为 get_a() 的函数。
使用 private 访问修饰符将要创建的类成员标记为可私有访问。
声明一个名为 a 的整数变量。
类主体结束。
使用类名和范围解析运算符来访问函数 get_a()。我们想定义函数在被调用时的作用。
函数 get_a() 应该在调用时返回变量 a 的值。
函数get_a()的定义结束。
使用类名和范围解析运算符来访问函数 set_a()。我们想定义函数在被调用时的作用。
将变量 val 的值赋给变量 a。
函数 set_a() 的定义结束。
调用 main() 函数。程序逻辑应添加到此函数的主体中。
创建一个 ClassA 的实例并将其命名为 a。
使用上面的类实例和函数 set_a() 给变量 a 赋值 20。
在控制台上在变量 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 的类。
使用 protected 访问修饰符将要创建的类成员标记为受保护。
创建一个名为 value 的整数变量。
类主体结束。
创建一个继承 ParentClass 的名为 ChildClass 的新类。
使用受保护的访问修饰符将要创建的类成员标记为可供子类访问。
创建一个名为 setId() 的函数，它接受一个整数值 x。
将变量 x 的值赋给变量值。
函数 setId() 的定义结束。
创建一个名为 displayValue() 的函数。
在控制台上打印名为 value 的变量的值以及其他文本。
函数 displayValue() 的主体结束。
名为 ChildClass 的类的主体结束。
调用 main() 函数。程序逻辑应添加到此函数的主体中。
创建一个 ChildClass 的实例并将其命名为 c。
使用上面的类实例和函数 setId() 为变量 x 赋值 21。
使用上面的类实例调用名为 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 的类。
使用 public 访问修饰符将我们即将创建的类成员标记为可公开访问。
创建一个名为 tutorial_name 的字符串变量。
创建一个名为 id 的整数变量。
创建一个名为 printname() 的函数。此函数未在类定义中定义。
创建一个名为printed() 的函数。该函数在类定义中定义。它的主体已添加到类定义中。
在控制台上打印变量 id 的值以及其他文本。请注意，这已添加到 printid() 函数的主体中。它只会在调用 printid() 函数时执行。
函数体 printid() 结束。
Guru99 类主体的结尾。
函数 printname() 的定义开始。
在控制台上打印变量 tutorial_name 的值以及其他文本。请注意，这已添加到 printname() 函数的主体中。它只会在调用 printname() 函数时执行。
printname()函数定义结束。
调用 main() 函数。程序逻辑应添加到此函数的主体中。
创建 Guru99 类的实例并将其命名为 guru99。
使用上述实例将 C++ 的值赋给变量 tutorial_name。
使用 guru99 实例为变量 id 赋值 1001。
使用实例 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 的类。
使用 public 访问修饰符将我们即将创建的成员标记为可公开访问。
为类创建一个构造函数。
调用构造函数时在控制台上打印的文本。 endl 是 C++ 关键字，表示结束行。它将鼠标光标移动到下一行。
类构造函数主体的结尾。
为类创建一个析构函数。
调用析构函数时在控制台上打印的文本。 endl 是 C++ 关键字，表示结束行。它将鼠标光标移动到下一行。
析构函数主体的结尾。
类主体结束。
调用 main() 函数。程序逻辑应添加到此函数的主体中。
创建一个类对象并将其命名为 a。将调用构造函数。
创建一个名为 p 的整数变量并将其赋值为 1。
使用变量 p 创建一个 if 语句块。
创建一个类对象并将其命名为 b。将调用析构函数。
if 语句主体的结尾。
main() 函数主体的结尾。

总结：

C++ 是面向对象的。
类构成了 C++ 使其面向对象的主要特性。
C++ 类将数据和用于操作数据的方法合二为一。
类是对象的蓝图。
类决定对象的形式。
类中包含的数据和方法称为类成员。
要访问类成员，您应该使用类的实例。
要创建一个类，我们使用 class 关键字。
类成员函数可以在类内部或外部定义。

带有打印示例的 C++ 标准模板库 (STL) 中的映射 C++ 多态与示例

C语言