Object Oriented Programming in C
面向对象的编程名词解释
面向对象的编程名词解释面向对象编程（Object-oriented programming，简称OOP）是一种编程范式，它将程序结构化为对象的集合，每个对象都可以接受消息、处理数据以及与其他对象进行交互。
在面向对象编程中，对象是程序的基本单元，它封装了数据和对数据的操作，并且通过定义类来创建对象的实例。
以下是一些与面向对象编程相关的常见名词解释：1. 类（Class）：类是面向对象编程中的模板，它定义了对象的属性和方法。
类是创建对象的蓝图。
2. 对象（Object）：对象是类的实例化，它具有类定义的属性和方法。
3. 属性（Property）：属性是对象的特征或数据，可以是基本类型（如整数、字符串等）或其他对象。
4. 方法（Method）：方法是类中定义的操作或行为，它可以访问和修改对象的属性。
5. 继承（Inheritance）：继承是面向对象编程的一个重要概念，它允许一个类继承另一个类的属性和方法。
子类可以重用父类的代码，同时可以扩展或修改父类的功能。
6. 多态（Polymorphism）：多态是指同一个方法可以在不同的类中具有不同的实现。
多态允许使用统一的接口来处理不同类型的对象，提高代码的可扩展性和灵活性。
7. 封装（Encapsulation）：封装是将数据和对数据的操作封装在对象中，通过访问器方法来控制对属性的访问和修改。
封装提供了数据的隐藏和保护，以及对外部的隔离。
8. 抽象（Abstraction）：抽象是将复杂的现实世界问题简化为模型或类的过程。
抽象屏蔽了不必要的细节，使得编程更加简洁和易于理解。
9. 接口（Interface）：接口是一种抽象类型，它定义了类应该实现的方法。
实现接口的类必须提供接口中定义的方法，以实现统一的接口规范。
10. 消息传递（Message Passing）：消息传递是对象之间进行通信的一种方式，一个对象通过向另一个对象发送消息来请求执行某个操作。
消息传递是面向对象编程中实现对象交互的基本机制。
美国计算机考试题型及答案
美国计算机考试题型及答案一、选择题1. Which of the following is an example of a high-level programming language?A) HTMLB) Assembly languageC) Machine codeD) Python答案：D) Python2. What is the purpose of an operating system?A) To provide physical protection for the computerB) To manage computer hardware and software resourcesC) To execute application programsD) To generate output for the user答案：B) To manage computer hardware and software resources3. Which of the following is NOT a data type in Python?A) IntegerB) StringC) BooleanD) FloatE) Array答案：E) Array4. What does RAM stand for?A) Random Access MemoryB) Read-Only MemoryC) Run-As-ManagedD) Remote Access Module答案：A) Random Access Memory5. What is the purpose of a firewall?A) To prevent unauthorized access to a networkB) To store and organize dataC) To connect multiple computers togetherD) To create and edit documents答案：A) To prevent unauthorized access to a network二、填空题1. The process of converting source code into machine code is called _________.答案：compilation2. The term __________ refers to a single executable unit of a program.答案：function3. In object-oriented programming, _________ is the process of creatinga new instance of a class.答案：instantiation4. The _________ command is used in the command line interface to change the current directory.答案：cd5. A __________ is a collection of related data items that can be accessed individually or as a whole.答案：array三、编程题题目：写一个函数，接受一个整数参数n，返回从1到n的所有偶数。
面向对象编程的基本概念
面向对象编程的基本概念面向对象编程的基本概念随着计算机技术的不断发展和应用的深入，编程语言也不断演化，出现了各种面向对象编程语言，如Java、C++、Python等。
面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它将计算机程序模块化，以对象作为程序设计的基本单元进行组织和设计。
本文将从面向对象编程的概念、特点、实现方式、应用等方面进行详细介绍。
一、面向对象编程的概念面向对象编程是一种编程思想和方法，它将现实世界的事物抽象为“对象”，以及对象之间的交互，来进行程序设计和模块化。
对象是指具有属性和方法的实体，它既可以是现实世界中的事物，也可以是抽象的概念，如字符串、整数、函数等。
而方法则是对象的行为，用于操作对象的属性，实现某种功能。
面向对象编程的核心思想就是封装、继承和多态。
二、面向对象编程的特点1、抽象化和封装化面向对象编程通过抽象化和封装化，将复杂的现实世界事物抽象为简单的对象，并将对象的内部细节隐藏起来，使得外部只能通过对象的接口来访问对象，从而实现了信息的隐藏和保护。
2、继承性继承性是面向对象编程的一个重要特点，它允许创建一个新的类，并从一个或多个现有类中继承属性和方法，从而减少了代码的冗余，提高了代码的重用性和灵活性。
3、多态性多态性是面向对象编程的另一个重要特点，它允许不同类型的对象调用同一个方法，不同对象按照自己的方式去实现这个方法，从而增强了程序的灵活性和可扩展性。
三、面向对象编程的实现方式1、类和对象类是具有相同属性和方法的对象的集合，它是面向对象编程的基本概念。
对象是类的实例，包含了类的所有属性和方法，可以通过对象来访问类的属性和方法。
2、封装封装是面向对象编程的特有功能，它可以将属性和方法隐藏起来，只留下外界可以访问的接口，从而达到保护数据的目的。
3、继承和多态继承是面向对象编程中的另一个重要概念，它可以复用已有的代码，减少代码冗余，提高代码的可重用性。
面向对象编程的设计和实现分析
面向对象编程的设计和实现分析面向对象编程（Object-Oriented Programming，简称OOP）是一种编程范式，它由一个或多个对象组成，对象之间相互协作来实现一定的功能。
与面向过程的编程相比，面向对象的编程更加注重事物本质和内在性质的描述，更加灵活和易于扩展。
在本文中，我们将探讨面向对象编程的设计和实现，分析其特点和优势，以及其面临的挑战和解决方法。
一、面向对象编程的特点面向对象编程具有以下特点：1. 抽象：面向对象编程将对象抽象为一种概念或实体，与具体实例相对应。
这种抽象能力使得面向对象编程更加灵活，同时也更加易于理解和扩展。
2. 封装：面向对象编程将对象的数据和方法封装在一个类中，从而实现数据的保护和程序的安全性。
封装能力在面向对象编程中起到了至关重要的作用。
3. 继承：面向对象编程通过继承来实现代码的重用和功能的扩展，使得程序更加灵活和易于维护。
4. 多态：面向对象编程的多态能力使得不同的对象能够调用相同的方法，从而实现了更加灵活和易于扩展的程序设计和实现。
二、面向对象编程的优势面向对象编程具有以下优势：1. 代码的重用性：面向对象编程通过继承和多态的方式实现了代码的重用，使得程序更加灵活和易于维护。
2. 代码的可扩展性：面向对象编程的多态和封装能力使得程序更加易于扩展和修改，从而减少了代码的维护成本。
3. 代码的安全性：面向对象编程的封装能力可以保护数据的安全性，使得程序更加安全可靠。
4. 程序的可读性：面向对象编程的抽象能力使得代码更加简洁，易于阅读和理解。
三、面向对象编程的实现面向对象编程的实现需要遵循以下步骤：1. 建立对象模型：首先需要分析程序的需求，建立一个对象模型。
2. 设计类和接口：在建立对象模型的基础上，需要设计具体的类和接口，在类和接口中定义对象的数据和方法。
3. 实现类和接口：设计完类和接口之后，需要具体实现类和接口，从而完成程序的实现。
4. 调试和测试：完成具体的程序实现之后，需要进行调试和测试，以确保程序的正确性和有效性。
面向对象程序设计完整版
Object- Oriented ProgrammingC++主讲成长生东华大学计算机科学与技术学院第一章概述§1.1 面向对象程序设计的基本思想C++是基于C语言发展的, 又冲破C语言局限的面向对象的程序设计语言。
它与Java语言都作为当前计算机科学的主流语言, 越来越受到用户的欢迎。
要弄清楚什么是面向对象的程序设计, 首先了解和回顾传统的( Pascal( 或C) ) 结构化程序设计方法及其设计思想、程序结构及特点。
SP(Structure Programming)是60年代诞生的针对当时爆发的所谓”软件危机”, 为此发展形成了现代软件工程学的基础。
SP的总的设计思想是:.自顶向下、层次化.逐步求精、精细化程序结构是按功能划分基本模块的树型结构, 使模块间的关系尽可能简单独立。
因此SP的程序的基本特点是:.按层次组织模块( 战略上划分战役).每一模块只有一个入口, 一个出口.代码和数据分离( 程序＝数据结构＋算法)归纳得到: SP把数据和过程( 代码、函数) 分离为相互独立的实体, 用数据代表问题空间中的客体借以表示实际问题中的信息; 程序代码则用来处理加工这些数据。
程序员在编程时, 必须时刻考虑所要处理的数据结构和类型。
对不同的数据格式即使要作同样的处理计算, 或者要对相同的数据格式作不同的处理都必须编写不同的程序( 如两个整型数和两个浮点数相加) 。
这样的编程方法, 即传统的SP方法设计出来的程序或系统其可重用的成分很少。
其次把数据和代码作为不同的分离实体时, 总存在着用错误的数据调用正确的程序模块, 或用正确的数据调用错误的程序模块的危险, 从而使数据与程序始终保持兼容, 已成为程序员的一个沉重的负担。
在开发一个大型软件课题中, 当工程进入到后期若用户改变了方案要求, 很容易使技术人员的前期工作受到摧毁性的打击, 使其前功尽弃。
为克服以上的弊端或者该SP方法难以控制处理的矛盾而产生了面向对象程序设计方法, 即Object －Oriented Programming――OOP。
C语言面向对象编程及其实现方法
C语言面向对象编程及其实现方法在计算机编程领域，面向对象编程（Object-Oriented Programming，简称OOP）是一种常用的编程范式。
C语言作为一种强大而灵活的编程语言，在实现面向对象编程方面也有其独特的方法。
本文将介绍C语言面向对象编程的基本概念、实现方法和相关技巧。
一、C语言面向对象编程基本概念1.类和对象面向对象编程的核心是类（Class）和对象（Object）。
类是一种抽象数据类型，描述了一类具有相同属性和方法的对象集合。
对象是类的实例，它具有类所描述的属性和方法。
2.封装封装是面向对象编程的一个重要特性，通过将数据和相关操作封装在类中，实现了数据的隐藏和保护。
只有类内部可以直接访问类的私有成员，外部只能通过类提供的接口访问数据。
3.继承继承允许一个类派生出另一个类，使得子类继承父类的属性和方法，同时可以根据需要增加新的属性和方法。
继承可以实现代码的重用，提高了软件的可维护性和扩展性。
4.多态多态是指同一操作对于不同的对象，可以有不同的行为。
通过多态，一个函数或方法可以具有多个不同的实现，从而实现了动态绑定和运行时多态性。
二、C语言实现面向对象编程的方法1.结构体和函数C语言中可以使用结构体和函数的组合来实现类和对象的概念。
结构体可以用来定义类的属性，而函数则可以定义类的方法。
通过使用指针来操作对象，可以实现对对象的封装和访问控制。
2.函数指针和回调函数函数指针是一种特殊的指针类型，它可以指向函数的地址。
通过使用函数指针和回调函数，可以在C语言中实现类似于虚函数（virtual function）和多态的功能。
3.宏和预处理器C语言的宏和预处理器可以用来定义类和对象的相关宏，从而简化代码的编写。
宏可以用来定义类的属性和方法，预处理器可以用来生成类的实例。
4.模块化编程面向对象编程倡导的模块化思想也可以在C语言中得到体现。
通过将代码分为不同的模块，每个模块实现特定的功能，可以提高代码的可读性、可维护性和重用性。
面向对象程序设计思想
面向对象程序设计思想面向对象程序设计（Object-Oriented Programming，简称OOP）是一种以对象为中心的编程范式，它将现实世界中的事物抽象为对象，并通过对象之间的交互来实现程序的运行。
面向对象程序设计的核心思想包括封装、继承和多态。
封装封装是面向对象程序设计中最基本的概念之一。
它指的是将数据（属性）和操作数据的方法（行为）组合在一起，形成一个对象。
封装的目的是隐藏对象的内部细节，只暴露出一个可以被外界访问的接口。
这样，对象的使用者不需要了解对象内部的实现细节，只需要通过接口与对象进行交互。
例如，在一个银行系统中，我们可以创建一个`Account`类，该类封装了账户的基本信息（如账号、余额）和对账户的操作（如存款、取款）。
用户在使用`Account`类时，只需要调用相应的方法，而不需要关心这些方法是如何实现的。
继承继承是面向对象程序设计中另一个重要的概念。
它允许一个类（子类）继承另一个类（父类）的属性和方法。
通过继承，子类可以扩展或修改父类的行为，而不需要重新编写代码。
继承支持代码的复用，使得程序设计更加简洁和高效。
例如，假设我们有一个`Animal`类，它定义了所有动物共有的属性和方法。
我们可以创建一个`Dog`类，它继承自`Animal`类。
`Dog`类将继承`Animal`类的所有属性和方法，并且可以添加一些特有的属性和方法，如`bark`。
多态多态是面向对象程序设计中的一个重要特性，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。
多态性使得程序设计更加灵活和可扩展。
多态性通常通过抽象类和接口来实现。
抽象类定义了一个或多个抽象方法，而具体的子类则提供了这些抽象方法的实现。
接口则定义了一组方法规范，不同的类可以实现同一个接口，但提供不同的实现。
例如，假设我们有一个`Shape`接口，它定义了一个`draw`方法。
我们可以创建`Circle`、`Square`等类，它们都实现了`Shape`接口。
面向对象程序设计
面向对象程序设计面向对象程序设计（Object-Oriented Programming，简称OOP）是一种编程范式，它使用“对象”来设计软件。
对象可以包含数据（通常称为属性）和代码（通常称为方法或函数）。
面向对象程序设计的核心概念包括封装、继承、多态和抽象。
封装封装是将数据（属性）和操作这些数据的方法（行为）绑定在一起的过程。
封装的目的是隐藏对象的内部状态和实现细节，只暴露出一个可以被外界访问的接口。
这样，对象的使用者不需要了解对象内部的复杂性，只需要通过公共接口与对象交互。
继承继承是一种机制，允许新创建的类（子类）继承现有类（父类）的属性和方法。
这使得代码重用变得可能，同时也支持层次结构的创建。
子类可以扩展或修改父类的行为，但通常保持父类的大部分功能。
多态多态性是指允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。
在面向对象编程中，多态性通常是通过方法重载（同一个类中多个同名方法，参数不同）和方法重写（子类重写父类的方法）实现的。
抽象抽象是简化复杂的现实世界问题的过程，只关注对于当前目标重要的方面，忽略不相关的细节。
在面向对象编程中，抽象通常是通过创建抽象类和接口来实现的。
抽象类可以包含抽象方法，这些方法没有具体的实现，必须由子类提供。
类和对象类是创建对象的蓝图或模板，定义了对象的结构和行为。
对象是根据类创建的实例，具有类定义的属性和方法。
每个对象都是唯一的，即使它们是同一个类的实例。
面向对象设计原则在面向对象设计中，有几个关键的设计原则，如单一职责原则、开放-封闭原则、里氏替换原则、接口隔离原则和依赖倒置原则等。
这些原则帮助开发者创建灵活、可维护和可扩展的系统。
面向对象的优势- 代码重用：通过继承和多态性，可以减少代码重复。
- 易于维护：封装和抽象使得修改系统的一部分不会影响其他部分。
- 模块化：系统被分解为独立的模块，每个模块负责特定的功能。
- 可扩展性：系统可以容易地扩展新功能，而不需要重写现有代码。
面向对象编程与面向过程编程的比较
面向对象编程与面向过程编程的比较面向对象编程（Object-Oriented Programming，OOP）和面向过程编程（Procedural Programming）是两种主流的编程范式。
虽然它们在很多方面都有相似之处，但也存在一些明显的差异。
本文将对面向对象编程和面向过程编程进行比较，分析它们各自的优势和劣势。
面向对象编程将数据和操作数据的函数封装在一起，形成一个对象。
对象是类的实例，类是一种描述相似对象特征和行为的模板。
面向过程编程则是将计算机程序视为一系列的步骤，即一组函数的集合，这些函数按照特定的顺序执行。
面向对象编程的特点是封装、继承和多态。
封装将数据和操作数据的函数封装在一起，隐藏内部实现细节，提供对外的接口。
继承允许创建新类，从一个或多个现有的类继承属性和方法，使代码更加灵活和可重用。
多态允许不同对象对同一消息作出不同的响应，提高代码的灵活性和扩展性。
面向过程编程注重对问题进行细分和精确的算法设计。
它将任务分解为一系列的步骤，按照特定的顺序执行。
面向过程编程更加注重函数和流程的设计，对数据的操作相对较少。
面向对象编程相对于面向过程编程具有以下优势：1.高内聚性和低耦合性：面向对象编程将数据和操作数据的函数封装在一起，每个对象只需要关注自己的数据和操作，提高了代码的内聚性。
同时，对象之间通过接口进行通信，降低了对象之间的依赖性，减少了代码的耦合性。
2.可重用性和可维护性：面向对象编程通过继承和多态实现代码的重用。
可以通过创建新类来扩展已有的类，并重用已有的代码和实现。
同时，面向对象编程的封装特性使得代码更易维护，当需要修改某个功能时，只需要修改相应的类即可，不需要修改整个系统。
3.扩展性和灵活性：面向对象编程能够很好地支持系统的扩展和变化。
通过继承和多态的特性，可以在不修改现有代码的情况下添加新的功能和行为。
这使得系统更加灵活和可扩展。
4.多人协作：面向对象编程使得多人协作更加容易。
国外将c面向对象的书
国外将c面向对象的书以下是一些关于C语言面向对象编程的书籍推荐：1. "Object-Oriented Programming in C" by Robert Lafore - 这本书介绍了如何在C语言中实现面向对象的编程范式，涵盖了类、对象、继承、多态等概念。
2. "Programming in C++ for Engineering and Science" by Larry Nyhoff - 这本书不仅介绍了C++语言的基本概念和语法，还重点关注了面向对象编程的应用，涵盖了类、对象、继承、多态等主题。
3. "C++ Primer" by Stanley B. Lippman, Josée Lajoie, and BarbaraE. Moo - 这本书是C++语言的经典教材，其中包含了丰富的面向对象编程的内容，从基础概念到高级特性都有覆盖。
4. "Object-Oriented Programming in ANSI-C" by Axel-Tobias Schreiner - 这本书是针对C语言编程者的面向对象编程入门指南，教授如何在C语言中使用结构体、指针和函数指针等技术实现面向对象编程。
5. "Data Structures and Algorithms in C++" by Michael T. Goodrich, Roberto Tamassia, and David M. Mount - 这本书主要关注数据结构和算法，但也涵盖了C++语言中的面向对象编程概念和实践。
希望这些推荐对您有所帮助！请注意，尽管这些书籍介绍了如何在C语言中实现面向对象编程，但C语言本身并不是为面向对象编程而设计的。
如果您更想深入学习面向对象编程，可能更适合选择C++或其他面向对象的编程语言。
面向对象程序设计c++语言
面向对象程序设计（Object-Oriented Programming，OOP）是一种编程范式，它主张将现实世界的对象抽象为具有数据和行为的程序实体。
C++ 是一种广泛使用的面向对象编程语言，其特点是将 C 语言的程序结构扩展为包含面向对象的特性。
C++ 的面向对象编程核心概念包括：1. 类（Class）：类是对象的抽象表示，定义了一组包括数据和方法的结构。
类可以看作是对象的蓝图或模板。
class MyClass {// 成员变量和成员函数的声明};1. 对象（Object）：是类的一个实例，具有由类定义的数据和方法。
通过类，我们可以创建多个相同类型的对象。
MyClass obj1;MyClass obj2;1. 封装（Encapsulation）：封装是将对象的内部结构（数据和方法）与外部环境隔离，提供一种访问和修改对象数据的安全机制。
// 使用 private 和 public 限定符实现封装class MyClass {private:int data;public:void setData(int d) {data = d;}int getData() {return data;}};1. 继承（Inheritance）：继承是面向对象编程中重用代码的一种方法，通过继承，一个类可以从另一个类派生出子类，并从基类继承成员变量和成员函数。
class Parent {// 基类（父类）的定义};class Child : public Parent {// 派生类（子类）的定义};1. 多态（Polymorphism）：多态是指基类的指针或引用可以指向派生类的对象，并调用派生类重写的虚函数。
class Base {public:virtual void func() {std::cout << "Base::func()" << std::endl;}};class Derived : public Base {public:void func() override {std::cout << "Derived::func()" << std::endl;}};Base* pObj = new Derived;pObj->func(); // 输出 "Derived::func()"以上简要介绍了 C++ 中面向对象程序设计的几个核心概念。
面向对象程序设计基础知识
面向对象程序设计基础知识面向对象程序设计（Object-oriented programming，简称OOP）是一种让计算机程序更具可维护性、可扩展性和可重用性的编程范式。
其中，基于类和对象的概念是核心要素。
本文将介绍面向对象程序设计的基础知识，包括类与对象、封装与继承、多态和抽象等。
一、类与对象类是面向对象程序设计的基本单位，是对一类具有相同属性和行为的对象的抽象描述。
类可以看作是对象的模板或蓝图，它定义了对象的属性和方法。
对象则是类的实例化，是具体的实体。
在面向对象程序设计中，类包含两个主要的成员：属性和方法。
属性是类的特性，描述了对象的状态；方法是类的行为，描述了对象的操作。
通过封装属性和方法，类实现了对数据和行为的封装，使得程序的逻辑更加清晰和灵活。
二、封装与继承封装是将类的属性和方法封装在一起，形成一个独立的单元。
通过封装，我们可以隐藏类的内部实现细节，只暴露必要的接口给外部使用。
这种数据与行为的封装增强了类的安全性和可靠性，同时也降低了程序的耦合性。
继承是面向对象程序设计的另一个重要概念。
通过继承，一个类可以继承另一个类的属性和方法，从而实现代码的复用和扩展。
继承关系可以形成类的层次结构，其中父类被称为超类或基类，子类被称为派生类。
派生类可以重写父类的方法或添加自己的方法，实现对父类的功能增强。
三、多态和抽象多态是指同一种类型的对象在不同情况下表现出不同的行为。
通过多态，我们可以根据对象的具体类型调用相应的方法，而不关心对象的具体实现。
多态提高了代码的灵活性和可扩展性，使得程序更易于维护和扩展。
抽象是将复杂的事物简化为一个易于理解的模型。
在面向对象程序设计中，抽象提供了接口和抽象类两种机制。
接口定义了一个类应该具有哪些方法，但不提供具体的实现；抽象类则是一种中间状态，既可以有定义了方法的具体实现，又可以有定义了接口的抽象方法。
通过接口和抽象类，我们可以实现代码的分离和模块化，提高代码的灵活性和复用性。
面向对象程序设计方法
面向对象程序设计方法
面向对象程序设计(Object-Oriented Programming, OOP)是一种程序设计思想，它强调将运行时环境中的对象与抽象出来的对象类型（或称为类）进行结合，以此来节约编程的工作量并提高程序的可操作性。
典型的OOP程序中，所有可用的类都可以通过继承，联系和组合组合成更高一级的类，而这些类又可以被用来构建新的对象。
OOP程序设计具有以下特征：
1、封装：封装是指将程序代码和数据结构组合在一起，使得它们可以单独使用，而不必考虑其他编程元素。
2、抽象：抽象是指将共性和特性从复杂的实体中抽离出来，建立一个通用的基类，用于管理、处理及访问某一类对象的相似之处。
3、多态：多态是指不同的对象，对同一操作可以表现出不同的行为。
4、继承：继承是指一个类的子类可以继承父类的特征，然后根据自身的需要，增加新的特征。
OOP程序设计的重要特点是它可以让程序员以可重用的模块来构建应用程序，从而大大降低程序编写及测试的工作量，也能够提升程序的可操作性。
类对象可以被构建成抽象层次结构，以便从可复用的模块中派生出更多新的类。
大量的类可以被组合在一起，形成一个功能更丰富的解决方案。
此外，多态性能让程序维护变得更加容易，因为改变一个类的行为，也不会影响到其他类。
C++经典书籍推荐
推荐一些C++的好书：1、《The C Programming language》（Keinighan & Dennis Ritchie 1988）2、《The C++ Programming Languague》特别版（Bjarne Stroustrup）3、《C++ primer》第三版（Stanley Lippmans）4、《Inside The C++ Object Model》（同上）5、《Effective C++》（Scott Meyers）6、《More Effective C++》（同上）7、《Exceptional C++》（Herb Sutter）8、《 C++标准程序库》（Nicolai M.Josuttis）)9、《Exceptional C++ Style》（Herb Sutter）10、《C++面向对象高效编程》（C++ Effective Object-Oriented Software Construction）11、《面向对象软件构造(Object-Oriented Software Construction)》12、《设计模式》（Design Patterns）13、看《Thinking In C++》不要看《C++变成死相》；14、一定要看《Thinking In C++》第二卷；15、《 C++ FAQs》（Marshall Cline, Greg Lomow）16、《 C++ Templates》（David Vandevoorde , Nicolai M.Josuttis）17、读《The Standard C++ Bible》(中文版：标准C++宝典)，掌握C++标准；21、《深入浅出MFC》（侯捷）22、《STL 源码剖析》（侯捷）23、《高质量程序设计指南——C++/C 》2nd （林锐韩永泉）24、《C++ 程序设计教程》2nd（钱能）25、《The Design and Evolution of C++》（Bjarne Stroustrup）26、《面向对象编程C++和Java比较教程》（Aviansh C Kak）27、《Essential COM 》28、《COM 技术内幕》29、《软件需求》30、《Object-Oriented Programming in C++》(Nicolai M.Josuttis)31、《泛型编程与STL》 Matthew H.Austern 著侯捷译34、看《程序设计实践》，并严格的按照其要求去做；总之，《深入C++系列》、《图灵丛书》和《C和C++实务精选》,这三套丛书，本本精彩.充分利用MSDN，因为它胜过任何一本编程参考书；MSDN是Microsoft提供的有关编程信息的最全面的资源，它包含微软最新的技术数据库，加上易学易用的全文检索功能，让您迅速找到任何您需要的技术参考数据，让您随时拥有与全世界菁英同步的技术，掌握最丰富的程序开发资源。
计算机编程模式
计算机编程模式计算机编程模式，也被称为编程范式，指的是一种特定的方法论或规范，用于解决特定问题的编程思维模式和技术实践。
不同的编程模式提供了不同的解决方案和开发方式，以更好地满足软件开发的需求。
本文将介绍一些常见的计算机编程模式，详细探讨它们的特点和应用场景。
一、面向对象编程（Object-Oriented Programming，简称OOP）面向对象编程是一种将程序中的操作与数据进行组合的编程范式。
它将程序划分为多个对象，并通过对象之间的交互来完成任务。
面向对象编程具有封装、继承和多态的特性，能够提高代码的可重用性和可维护性。
它在开发大型软件系统时非常常见，如Java、C++等编程语言都支持面向对象编程。
面向对象编程的主要特点包括：1. 封装：将数据和操作封装在对象中，防止外部直接访问和修改。
2. 继承：通过继承机制，一个类可以继承另一个类的属性和方法，提高代码的复用性。
3. 多态：同一方法在不同的对象上可以有不同的实现，提供了更灵活的代码设计方式。
面向对象编程适用于需要管理大量对象并且需要灵活扩展的项目，例如图形用户界面（GUI）开发、游戏开发等。
二、函数式编程（Functional Programming，简称FP）函数式编程是一种以函数为主要构造单元的编程模式。
在函数式编程中，函数是第一等公民，具有独立性和不可变性。
函数式编程推崇将程序设计视为数学函数的组合，强调函数之间的独立性和无副作用。
常见的函数式编程语言包括Haskell、Lisp等。
函数式编程的主要特点包括：1. 不可变性：函数式编程中的数据是不可变的，函数只会返回新的数据，而不会改变原始数据。
2. 引用透明性：同样的输入得到同样的输出，函数没有副作用。
3. 高阶函数：函数可以作为参数传递给其他函数，也可以作为返回值返回。
函数式编程适用于处理大规模数据集、并行计算等应用场景，由于函数的独立性和不可变性，可以显著提高程序的可读性和可维护性。
面向对象程序设计(英文)
Object-Oriented ProgrammingObject-oriented programming is based on three fundamental concepts: data abstraction, inheritance, and dynamic binding. In C++ we use classes for data abstraction and class derivation to inherit one class from another: A derived class inherits the members of its base class(es). Dynamic binding lets the compiler determine at run time whether to use a function defined in the base or derived class.Inheritance and dynamic binding streamline our programs in two ways: They make it easier to define new classes that are similar, but not identical, to other classes, and they make it easier for us to write programs that can ignore the details of how those similar types differ.。
Many applications are characterized by concepts that are related but slightly different. For example, our bookstore might offer different pricing strategies for different books. Some books might be sold only at a given price. Others might be sold subject to some kind of discount strategy. We might give a discount to purchasers who buy a specified number of copies of the book. Or we might give a discount for only the first few copies purchased but charge full price for any bought beyond a given limit.Object-oriented programming (OOP) is a good match to this kind of application. Through inheritance we can define types that model the different kinds of books. Through dynamic binding we can write applications that use these types but that can ignore the type-dependent differences.The ideas of inheritance and dynamic binding are conceptually simple but have profound implications for how we build our applications and for the features that programming languages must support. Before covering how C++ supports OOP, we'll look at the concepts that are fundamental to this style of programming.An OverviewThe key idea behind OOP is polymorphism. Polymorphism is derived from a Greek word meaning "many forms." We speak of types related by inheritance as polymorphic types, because in many cases we can use the "many forms" of a derived or base type interchangeably. As we'll see, in C++, polymorphism applies only to references or pointers to types related by inheritance.InheritanceInheritance lets us define classes that model relationships among types, sharing what is common and specializing only that which is inherently different. Members defined by the base class are inherited by its derived classes. The derived class can use, without change, those operations that do not depend on the specifics of the derived type. It can redefine those member functions that do depend on its type, specializing the function to take into account the peculiarities of the derived type. Finally, a derived class may define additional members beyond those it inherits from its base class.Classes related by inheritance are often described as forming an inheritance hierarchy. There is one class, referred to as the root, from which all the other classes inherit, directly or indirectly. In our bookstore example, we will define a base class, which we'll name Item_base, to represent undiscounted books. From Item_base we will inherit a second class, which we'll name Bulk_item, to represent books sold with a quantity discount.At a minimum, these classes will define the following operations:● an operation named book that will return the ISBN● an operation named net_price that returns the price for purchasinga specified number of copies of a bookClasses derived from Item_base will inherit the book function without change: The derived classes have no need to redefine what it means to fetch the ISBN. On the other hand, each derived class will need to define its own version of the net_price function to implement an appropriate discount pricing strategy.In C++, a base class must indicate which of its functions it intends for its derived classes to redefine. Functions defined as virtual are ones that the base expects its derived classes to redefine. Functions that the base class intends its children to inherit are not defined as virtual.Given this discussion, we can see that our classes will define three (const) member functions:• A nonvirtual function, std::string book(), that returns the ISBN.It will be defined by Item_base and inherited by Bulk_item.•Two versions of the virtual function, double net_price(size_t), to return the total price for a given number of copies of a specificbook. Both Item_base and Bulk_item will define their own versions of this function.Dynamic BindingDynamic binding lets us write programs that use objects of any type in an inheritance hierarchy without caring about the objects' specific types. Programs that use these classes need not distinguish between functions defined in the base or in a derived class.For example, our bookstore application would let a customer select several books in a single sale. When the customer was done shopping, the application would calculate the total due. One part of figuring the final bill would be to print for each book purchased a line reporting the total quantity and sales price for that portion of the purchase.We might define a function named print_total to manage this part of the application. The print_total function, given an item and a count, should print the ISBN and the total price for purchasing the given number of copies of that particular book. The output of this function should look like:ISBN: 0-201-54848-8 number sold: 3 total price: 98ISBN: 0-201-82470-1 number sold: 5 total price: 202.5Our print_total function might look something like the following:// calculate and print price for given number of copies, applying any discountsvoid print_total(ostream &os,const Item_base &item, size_t n){os << "ISBN: " << item.book() // calls Item_base::book<< "\tnumber sold: " << n << "\ttotal price: "// virtual call: which version of net_price to call is resolved at run time<< _price(n) << endl;}The function's work is trivial: It prints the results of calling book and net_price on its item parameter. There are two interesting things about this function.First, even though its second parameter is a reference to Item_base, we can pass either an Item_base object or a Bulk_item object to this function.Second, because the parameter is a reference and the net_price function is virtual, the call to net_price will be resolved at run time. The version of net_price that is called will depend on the type of the argument passed to print_total. When the argument to print_total is a Bulk_item, the version of net_price that is run will be the one defined in Bulk_item that applies a discount. If the argument is an Item_base object, then the call will be to the version defined by Item_base.C++, dynamic binding happens when a virtual function is called through a reference (or a pointer) to a base class. The fact that a reference (or pointer) might refer to either a base- or a derived-class object is the key to dynamic binding. Calls to virtual functions made through a reference (or pointer) are resolved at run time: The function that is called is the one defined by the actual type of the object to which the reference (or pointer) refers.Defining Base and Derived ClassesIn many ways, base and derived classes are defined like other classes we have already seen. However, there are some additional features that are required when defining classes in an inheritance hierarchy. This section will present those features. Subsequent sections will see how use of these features impacts classes and the programs we write using inherited classes.Defining a Base ClassLike any other class, a base class has data and function members that define its interface and implementation. In the case of our (very simplified) bookstore pricing application, our Item_base class defines the book and net_price functions and needs to store an ISBN and the standard price for the book:// Item sold at an undiscounted price// derived classes will define various discount strategiesclass Item_base {public:Item_base(const std::string &book = "",double sales_price = 0.0):isbn(book), price(sales_price) { }std::string book() const { return isbn; }// returns total sales price for a specified number of items // derived classes will override and apply different discount algorithmsvirtual double net_price(std::size_t n) const{ return n * price; }virtual ~Item_base() { }private:std::string isbn; // identifier for the itemprotected:double price; // normal, undiscounted price};For the most part, this class looks like others we have seen. It defines a constructor along with the functions we have already described. That constructor uses default arguments (Section 7.4.1, p. 253), which allows it to be called with zero, one, or two arguments. It initializes the data members from these arguments.The new parts are the protected access label and the use of the virtual keyword on the destructor and the net_price function. We'll explain virtual destructors in Section 15.4.4 (p. 587), but for now it is worth noting that classes used as the root class of an inheritance hierarchy generally define a virtual destructor.Base-Class Member FunctionsThe Item_base class defines two functions, one of which is preceded by the keyword virtual. The purpose of the virtual keyword is to enable dynamic binding. By default, member functions are nonvirtual. Calls to nonvirtual functions are resolved at compile time. To specify that a function is virtual, we precede its return type by the keyword virtual. Any nonstatic member function, other than a constructor, may be virtual. The virtual keyword appears only on the member-function declaration inside the class. The virtual keyword may not be used on a function definition that appears outside the class body.Access Control and InheritanceIn a base class, the public and private labels have their ordinary meanings: User code may access the public members and may not access theprivate members of the class. The private members are accessible only to the members and friends of the base class. A derived class has the same access as any other part of the program to the public and private members of its base class: It may access the public members and has no access to the private members.Sometimes a class used as a base class has members that it wants to allow its derived classes to access, while still prohibiting access to those same members by other users. The protected access label is used for such members. A protected member may be accessed by a derived object but may not be accessed by general users of the type.Our Item_base class expects its derived classes to redefine the net_price function. To do so, those classes will need access to the price member. Derived classes are expected to access isbn in the same way as ordinary users: through the book access function. Hence, the isbn member is private and is inaccessible to classes that inherit from Item_base.protected MembersThe protected access label can be thought of as a blend of private and public:●Like private members, protected members are inaccessible to usersof the class.●Like public members, the protected members are accessible to classesderived from this class.In addition, protected has another important property:A derived object may access the protected members of its base class only through a derived object. The derived class has no special access to the protected members of base type objects.As an example, let's assume that Bulk_item defines a member function that takes a reference to a Bulk_item object and a reference to an Item_base object. This function may access the protected members of its own object as well as those of its Bulk_item parameter. However, it has no special access to the protected members in its Item_base parameter:void Bulk_item::memfcn(const Bulk_item &d, const Item_base &b){// attempt to use protected memberdouble ret = price; // ok: uses this->priceret = d.price; // ok: uses price from a Bulk_item objectret = b.price; // error: no access to price from an Item_base }The use of d.price is okay, because the reference to price is through an object of type Bulk_item. The use of b.price is illegal because Bulk_item has no special access to objects of type Item_base.Derived ClassesTo define a derived class, we use a class derivation list to specify the base class(es). A class derivation list names one or more base classes and has the formclass classname: access-label base-classwhere access-label is one of public, protected, or private, and base-class is the name of a previously defined class. As we'll see, a derivation list might name more than one base class. Inheritance from a single base class is most common and is the topic of this chapter.We'll have more to say about the access label used in a derivation list in Section 15.2.5 (p. 570). For now, what's useful to know is that the access label determines the access to the inherited members. When we want to inherit the interface of a base class, then the derivation should be public.A derived class inherits the members of its base class and may define additional members of its own. Each derived object contains two parts: those members that it inherits from its base and those it defines itself. Typically, a derived class (re)defines only those aspects that differ from or extend the behavior of the base.Defining a Derived ClassIn our bookstore application, we will derive Bulk_item from Item_base, so Bulk_item will inherit the book, isbn, and price members. Bulk_item must redefine its net_price function and define the data members needed for that operation:// discount kicks in when a specified number of copies of same book are sold// the discount is expressed as a fraction used to reduce the normal priceclass Bulk_item : public Item_base {public:// redefines base version so as to implement bulk purchase discount policydouble net_price(std::size_t) const;private:std::size_t min_qty; // minimum purchase for discount to apply double discount; // fractional discount to apply};Each Bulk_item object contains four data elements: It inherits isbn and price from Item_base and defines min_qty and discount. These latter two members specify the minimum quantity and the discount to apply once that number of copies are purchased.Derived Classes and virtual FunctionsOrdinarily, derived classes redefine the virtual functions that they inherit, although they are not requried to do so. If a derived class does not redefine a virtual, then the version it uses is the one defined in its base class.A derived type must include a declaration for each inherited member it intends to redefine. Our Bulk_item class says that it will redefine the net_price function but will use the inherited version of book.Public, Private, and Protected InheritanceAccess to members defined within a derived class is controlled in exactly the same way as access is handled for any other class (Section 12.1.2, p. 432). A derived class may define zero or more access labels that specify the access level of the members following that label. Access to the members the class inherits is controlled by a combination of the access level of the member in the base class and the access label used in the derived class' derivation list.The base class itself specifies the minimal access control for its own members. If a member is private in the base class, then only the base class and its friends may access that member. The derived class has no access to the private members of its base class, nor can it make thosemembers accessible to its own users. If a base class member is public or protected, then the access label used in the derivation list determines the access level of that member in the derived class:•In public inheritance, the members of the base retain their access levels: The public members of the base are public members of the derived and the protected members of the base are protected in the derived.•In protected inheritance, the public and protected members of the base class are protected members in the derived class.•In private inheritance, all the members of the base class are private in the derived class.As an example, consider the following hierarchy:class Base {public:void basemem(); // public memberprotected:int i; // protected member// ...};struct Public_derived : public Base {int use_base() { return i; } // ok: derived classes can access i// ...};struct Private_derived : private Base {int use_base() { return i; } // ok: derived classes can access i};All classes that inherit from Base have the same access to the members in Base, regardless of the access label in their derivation lists. The derivation access label controls the access that users of the derived class have to the members inherited from Base:Base b;Public_derived d1;Private_derived d2;b.basemem(); // ok: basemem is publicd1.basemem(); // ok: basemem is public in the derived classd2.basemem(); // error: basemem is private in the derived classBoth Public_derived and Private_derived inherit the basemem function. That member retains its access level when the inheritance is public, so d1 can call basemem. In Private_derived, the members of Base are private; users of Private_derived may not call basemem.The derivation access label also controls access from indirectly derived classes:struct Derived_from Private : public Private_derived {// error: Base::i is private in Private_derivedint use_base() { return i; }};struct Derived_from_Public : public Public_derived {// ok: Base::i remains protected in Public_derivedint use_base() { return i; }};Classes derived from Public_derived may access i from the Base class because that member remains a protected member in Public_derived. Classes derived from Private_derived have no such access. To them all the members that Private_base inherited from Base are private.Interface versus Implementation InheritanceA publicly derived class inherits the interface of its base class; it has the same interface as its base class. In well-designed class hierarchies, objects of a publicly derived class can be used wherever an object of the base class is expected.Classes derived using either private or protected do not inherit the base-class interface. Instead, these derivations are often referred to as implementation inheritance. The derived class uses the inherited class in its implementation but does not expose the fact of the inheritance as part of its interface.As we'll see in before, whether a class uses interface or implementation inheritance has important implications for users of the derived class.Constructors and Copy ControlThe fact that each derived object consists of the (nonstatic) members defined in the derived class plus one or more base-class subobjectsaffects how derived-type objects are constructed, copied, assigned, and destroyed. When we construct, copy, assign, or destroy an object of derived type, we also construct, copy, assign, or destroy those base-class subobjects.Constructors and the copy-control members are not inherited; each class defines its own constructor(s) and copy-control members. As is the case for any class, synthesized versions of the default constructor and the copy-control members will be used if the class does not define its own versions.Base-Class Constructors and Copy ControlConstructors and copy control for base classes that are not themselves a derived class are largely unaffected by inheritance. Our Item_base constructor looks like many we've seen before:Item_base(const std::string &book = "",double sales_price = 0.0):isbn(book), price(sales_price) { }The only impact inheritance has on base-class constructors is that there is a new kind of user that must be considered when deciding which constructors to offer. Like any other member, constructors can be made protected or private. Some classes need special constructors that are intended only for their derived classes to use. Such constructors should be made protected. protected。
[转]OOPC：Object-OrientedProgramminginC
![[转]OOPC：Object-OrientedProgramminginC](https://img.taocdn.com/s3/m/481e5117eef9aef8941ea76e58fafab069dc446b.png)
[转]OOPC：Object-OrientedProgramminginC OOPC是指OOP(Object-Oriented Programming)与C语⾔的结合，它是⼀个⾯向对象C语⾔编程框架。
它是⼀套C语⾔的宏，定义了OOP 概念的关键字，借助于这⼀套宏，实现⾯向对象的特性，如类、对象、继承、接⼝、多态、消息等。
C＋＋对于⼤型软件架构的良好可控性，和对以后程序员维护代码时良好的可读性；然⽽就⽬前来说，在嵌⼊式领域⼴泛的使⽤C＋＋显然是不现实的事情。
⼀般的嵌⼊式系统开发中只⽤到了其中的⼀⼩部分功能，⽽不需要全部的机制，⽐如多重继承、运算符重载等。
因此，许多嵌⼊式系统的开发者就舍弃了C++的庞⼤⾝躯⽽回归到精简的C环境中。
⼀般情况下，⼀个更容易扩展、维护的软件通常采⽤的是OOP的思想，添加⼀个原本不存在的相对⽆关单独的个体，总⽐在⼀个已经存在的过程内硬塞进去⼀个对象要简单；⽽且⾯向过程更容易导致混乱的维护。
然⽽舍弃C++的同时也舍弃了珍贵的OOP能⼒，实在太可惜了。
C语⾔良好的可移植性，对内存等良好的操作性以及执⾏之速度均是⼀般嵌⼊式产品的不⼆⾸选。
我们要应此放弃C＋＋吗？当然不，幸好已经有很多优秀的设计师为我们指明了C语⾔OOP化的道路。
虽然OOPC语法不如C++那么简洁，但是OOPC也有亮丽的特⾊，就是编译后的程序所占的内存空间⽐C++⼩的多，执⾏效率⾼，适⽤于Embedded System。
Axel-Tobias Schreiner阐述了利⽤普通ANSI-C同样可以实现⾯向对象思想，1993年10⽉出版图书《Object-oriented Programming with ANSI-C》阐述了利⽤ANSI-C实现⾯向对象编程思想的基础。
LW_OOPC（Light Weight Object-oriented Programming with C,2010.1.24开源）轻量级的⾯向对象C编程框架是由台湾⾼焕堂先⽣以及他的MISOO团队创作了第⼀个版本之后，⼜由⾦永华改进优化，再以LGPL协议开源出来的。
oop方案
OOP方案引言在软件开发中，面向对象编程（Object-Oriented Programming，OOP）是一种常用的编程范式。
它将程序设计和构建过程分为对象的定义和对象的实例化两个步骤，通过面向对象的思想和技术，使得软件的设计、开发和维护更加模块化和可扩展。
本文将介绍面向对象编程的基本概念、原则和常用的设计模式，以及如何使用OOP来设计和实现一个项目或系统。
面向对象编程的基本概念面向对象编程的基本概念包括类（Class）、对象（Object）、封装（Encapsulation）、继承（Inheritance）和多态（Polymorphism）等。
类（Class）类是面向对象编程的基本概念，它是对一类具有相同属性和方法的对象的抽象。
类定义了对象的结构和行为，它是对象的模板。
在面向对象编程中，类通常包括成员变量和成员方法。
成员变量是类的属性或状态，成员方法是类的行为或操作。
对象（Object）对象是类的实例，它具有类定义的属性和方法。
面向对象编程中的操作和数据都是通过对象进行的。
对象之间可以进行消息传递和交互。
一个对象通过调用其他对象的方法来实现自己的功能。
封装（Encapsulation）封装是面向对象编程的一个重要原则，它指的是将数据和操作封装在一个类中，通过访问控制来隐藏实现细节。
封装可以防止外部对类的直接访问和修改，只能通过类提供的公共接口来访问和操作。
这样可以增加程序的安全性和稳定性。
继承（Inheritance）继承是面向对象编程的另一个重要原则，它允许一个对象使用另一个对象的属性和方法。
通过继承，可以实现代码的重用和扩展。
在继承关系中，有一个基类（父类）和派生类（子类）的概念。
派生类可以继承基类的属性和方法，并且可以在此基础上添加新的属性和方法。
多态（Polymorphism）多态是面向对象编程的一个重要特性，它使得一个对象可以有多种形态。
多态可以实现方法的重载和重写，对于不同类型的对象可以有不同的行为。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
Object Oriented Programming in C Embedded software development is slowly moving towards object oriented analysis, design and programming. The introduction of object oriented technologies in some systems has not happened due to lack of C++ support on some platforms.This article focuses on platforms where C++ compilers are not available. The developers working on these platforms should still be able to use object oriented analysis and design. When it comes to final code development they can use C.The following sections cover an example of C++ code and its implementation in C.∙C++ Source Code: C++ source files implementing TerminalManager and Terminal classes.∙ C Source Code: TerminalManager and Terminal implemented in C for a platform that does not support C++.C++ Source CodeTerminal Manager and Terminal C++ header and source files are shown below:Terminal ManagerTerminalManager.hpp// TerminalManager header file. We will be using this class// as an example for Object Oriented Programming in C.#include "Terminal.hpp"class TerminalManager{private:enum {MAX_TERMINALS=500};Terminal terminals[MAX_TERMINALS];Terminal *FindTerminal(int terminalId);public:TerminalManager();~TerminalManager();void HandleMessage(Msg* pMsg);};TerminalManager.cpp// TerminalManager source file. We will be using this class// as an example for Object Oriented Programming in C.#include <stdio.h>#include "TerminalManager.hpp"#include "Msg.hpp"TerminalManager::TerminalManager(){//...}TerminalManager::~TerminalManager(){}void TerminalManager::HandleMessage(Msg* pMsg){int status, status1;int terminalId = pMsg->GetTerminalId();Terminal *pTerm = FindTerminal(terminalId);Terminal *pOtherTerm = NULL;if (pTerm != NULL){switch (pMsg->GetType()){case CREATE_TERMINAL:pTerm->Activate((const TerminalCreateMsg *)pMsg);break;case DELETE_TERMINAL:pTerm->Deactivate((const TerminalDeleteMsg *) pMsg);break;case RUN_DIAGNOSTICS:status = pTerm->HandleRunDiagnostics((const RunDiagnosticsMsg *) pMsg);break;case PERFORM_SWITCHOVER:pOtherTerm = FindTerminal(pMsg->GetOtherTerminalId());status = pTerm->HandleOutOfService();status1 = pOtherTerm->HandleInService();break;}}delete pMsg;}Terminal *TerminalManager::FindTerminal(int terminalId){if (terminalId < MAX_TERMINALS){return (&terminals[terminalId]);}else{return NULL;}}TerminalTerminal.hpp// Terminal class header file.// Forward declaration for messagesclass TerminalCreateMsg;class TerminalDeleteMsg;class RunDiagnosticsMsg;class Msg;// Terminal classclass Terminal{enum { UNKNOWN = 0 };enum {OUT_OF_SERVICE=1, INSERVICE=2};//...int terminalId;int terminalType;int terminalStatus;void SendMessage(Msg *pMsg);public:void Activate(const TerminalCreateMsg *pMsg);void Deactivate(const TerminalDeleteMsg *pMsg);int HandleRunDiagnostics(const RunDiagnosticsMsg *pMsg);int HandleOutOfService();int HandleInService();Terminal();~Terminal();};Terminal.cpp// Terminal class source file.#include "Terminal.hpp"#include "Msg.hpp"void Terminal::SendMessage(Msg *pMsg){//...}Terminal::Terminal(){terminalId = UNKNOWN;terminalType = UNKNOWN;terminalStatus = UNKNOWN;}Terminal::~Terminal(){//...}int Terminal::HandleRunDiagnostics(const RunDiagnosticsMsg *pMsg) {int status = 1;//...return status;}int Terminal::HandleOutOfService(){int status = 1;terminalStatus = OUT_OF_SERVICE;//...return status;}int Terminal::HandleInService(){int status = 1;terminalStatus = INSERVICE;//...return status;}void Terminal::Activate(const TerminalCreateMsg *pMsg){terminalId = pMsg->GetTerminalId();terminalType = pMsg->GetTerminalType();terminalStatus = pMsg->GetTerminalStatus();//...TerminalCreateAck *pAck = new TerminalCreateAck(terminalId, terminalStatus);SendMessage(pAck);}void Terminal::Deactivate(const TerminalDeleteMsg *pMsg){//...terminalId = UNKNOWN;terminalType = UNKNOWN;terminalStatus = UNKNOWN;//...}Msg.hpp// Messages used by the Terminal and TerminalManager classes.enum MsgType{CREATE_TERMINAL,DELETE_TERMINAL,RUN_DIAGNOSTICS,PERFORM_SWITCHOVER};class Msg{//...int msgType;int terminalType;int terminalId;int otherTerminalId;int terminalStatus;public:MsgType GetType() const;int GetTerminalId() const;int GetOtherTerminalId() const;int GetTerminalType() const;};// Message used to create a terminalclass TerminalCreateMsg : public Msg{public:int GetTerminalStatus() const;};// Acknowledgement to Terminal Create message.class TerminalCreateAck : public Msg{public:TerminalCreateAck(int terminalId, int terminalStatus); };// Terminal Delete messageclass TerminalDeleteMsg : public Msg{};C Source CodeTerminal Manager and Terminal C header and source files are shown below. The important points to note are:∙Data members of a class map to C structures∙Methods of a class map to C functions with the "data member" structure pointer as the first parameter.TerminalManagerTerminalManager.h/*TerminalManager header file. We will be using this classas an example for Object Oriented Programming in C.*/#include "Terminal.h"#define MAX_TERMINALS 500/* Structure contains all data used by the Terminal Manager. */typedef struct{Terminal terminals[MAX_TERMINALS];} TerminalManager;/*ANSI C Function prototypes of all functions that operateon the TerminalManager structure.*/void TerminalManager_Construct(TerminalManager *pMgr);void TerminalManager_Destroy(TerminalManager *pMgr);void TerminalManager_HandleMessage(TerminalManager *pMgr, Msg* pMsg);Terminal Manager.c/*TerminalManager source file. We will be using this classas an example for Object Oriented Programming in C.*/#include <stdio.h>#include "TerminalManager.h"#include "Msg.h"#include <stdlib.h>Terminal *TerminalManager_FindTerminal(TerminalManager *pMgr, int terminalId) {if (terminalId < MAX_TERMINALS){return (&(pMgr->terminals[terminalId]));}else{return NULL;}}void TerminalManager_Construct(TerminalManager *pMgr){int i;/*C will not call construction functions, so loop through all call theconstruction functions for all terminals.*/for (i=0; i < MAX_TERMINALS; i++){Terminal_Construct(&(pMgr->terminals[i]));}}void TerminalManager_Destroy(TerminalManager *pMgr){int i;/*C will not call destruction functions, so loop through all call thedestruction functions for all terminals.*/for (i=0; i < MAX_TERMINALS; i++){Terminal_Destroy(&(pMgr->terminals[i]));}}void TerminalManager_HandleMessage(TerminalManager *pMgr, Msg* pMsg){int status, status1;int terminalId = pMsg->terminalId;Terminal *pTerm = TerminalManager_FindTerminal(pMgr, terminalId);Terminal *pOtherTerm = NULL;/*Switch on the message type and invoke the Terminal's message handlers forthe terminal specified in the message. Here the terminal manager takescare of indexing into the terminal structure and it passes the pointerto the terminal handler functions. Due to this design, implementationof the terminal handler functions just focus on handling the specifiedterminal.*/if (pTerm != NULL){switch (pMsg->msgType){case CREATE_TERMINAL:Terminal_Activate(pTerm, (const TerminalCreateMsg *)pMsg);break;case DELETE_TERMINAL:Terminal_Deactivate(pTerm, (const TerminalDeleteMsg *) pMsg);break;case RUN_DIAGNOSTICS:status = Terminal_HandleRunDiagnostics(pTerm, (const RunDiagnosticsMsg *) break;case PERFORM_SWITCHOVER:pOtherTerm = TerminalManager_FindTerminal(pMgr, pMsg->otherTerminalId); status = Terminal_HandleOutOfService(pTerm);status1 = Terminal_HandleInService(pOtherTerm);break;}}free(pMsg);}TerminalTerminal.h/* Terminal struct header file. */#include "Msg.h"#define UNKNOWN 0#define OUT_OF_SERVICE 1#define INSERVICE 2/* Terminal struct */typedef struct{/*...*/int terminalId;int terminalType;int terminalStatus;} Terminal;/*Prototypes for Terminal structure related functions. Helperfunctions needed by these functions are marked static are notincluded here.*/void Terminal_Activate(Terminal *pTerm, const TerminalCreateMsg *pMsg);void Terminal_Deactivate(Terminal *pTerm, const TerminalDeleteMsg *pMsg);int Terminal_HandleRunDiagnostics(Terminal *pTerm, const RunDiagnosticsMsg *pMsg); int Terminal_HandleOutOfService(Terminal *pTerm);int Terminal_HandleInService(Terminal *pTerm);void Terminal_Construct(Terminal *pTerm);void Terminal_Destroy(Terminal *pTerm);Terminal.c/* Terminal struct source file. */#include "Terminal.h"#include "Msg.h"#include <stdlib.h>/*Terminal_SendMessage is not visible to outside the Terminal.c file.This is equivalent to a private method in C++.*/static void Terminal_SendMessage(Terminal *pTerm, Msg *pMsg){/*...*/}void Terminal_Construct(Terminal *pTerm){pTerm->terminalId = UNKNOWN;pTerm->terminalType = UNKNOWN;pTerm->terminalStatus = UNKNOWN;}void Terminal_Destroy(Terminal *pTerm){/*...*/}int Terminal_HandleRunDiagnostics(Terminal *pTerm, const RunDiagnosticsMsg *pMsg){int status = 1;/*...*/return status;}int Terminal_HandleOutOfService(Terminal *pTerm){int status = 1;pTerm->terminalStatus = OUT_OF_SERVICE;/*...*/return status;}int Terminal_HandleInService(Terminal *pTerm){int status = 1;pTerm->terminalStatus = INSERVICE;/*...*/return status;}void Terminal_Activate(Terminal *pTerm, const TerminalCreateMsg *pMsg){TerminalCreateAck *pAck;pTerm->terminalId = pMsg->header.terminalId;pTerm->terminalType = pMsg->header.terminalType;pTerm->terminalStatus = pMsg->header.terminalStatus;/*...*/pAck = (TerminalCreateAck *)malloc(sizeof(TerminalCreateAck));pAck->header.terminalId = pTerm->terminalId;pAck->header.terminalStatus = pTerm->terminalStatus;Terminal_SendMessage(pTerm, (Msg *)pAck);}void Terminal_Deactivate(Terminal *pTerm, const TerminalDeleteMsg *pMsg) {/*...*/pTerm->terminalId = UNKNOWN;pTerm->terminalType = UNKNOWN;pTerm->terminalStatus = UNKNOWN;/*...*/}Msg.h/* Messages used by the Terminal and TerminalManager classes. */#ifndef MSG_H#define MSG_Henum MsgType{CREATE_TERMINAL,DELETE_TERMINAL,RUN_DIAGNOSTICS,PERFORM_SWITCHOVER};typedef struct{/*...*/int msgType;int terminalType;int terminalId;int otherTerminalId;int terminalStatus;} Msg;/* Message used to create a terminal. */typedef struct{Msg header;}TerminalCreateMsg;/* Acknowledgement to Terminal Create message. */typedef struct{Msg header;} TerminalCreateAck;/* Terminal Delete message */typedef struct{Msg header;} TerminalDeleteMsg;typedef struct{Msg header;} RunDiagnosticsMsg;#endifExplore More∙Compare C++ and the equivalent C code for class declarations and method invocation∙Compare C++ and the equivalent C code for inheritance and virtual functions.。