C面向对象编程试题及答案解析

C面向对象编程试题及答案解析考试时间：______分钟总分：______分姓名：______一、选择题1.下列关于面向对象编程的描述中，正确的是（）。A.面向对象编程是一种面向过程的编程范式B.面向对象编程通过封装、继承和多态来实现代码的模块化C.面向对象编程强调程序的执行效率D.面向对象编程只适用于小型项目2.在C语言中，实现封装的主要方式是（）。A.使用宏定义B.使用函数C.使用结构体和访问控制关键字D.使用指针3.下列关于类的描述中，正确的是（）。A.类是对象的实例B.类是描述对象属性和行为的模板C.类是C语言中的关键字D.类没有成员变量4.在C语言中，创建对象的语句是（）。A.`typedefstruct{}Object;`B.`Objectobj;`C.`Object*obj=malloc(sizeof(Object));`D.`Objectobj={};`5.下列关于继承的描述中，正确的是（）。A.继承只能单继承B.继承可以实现代码复用C.继承会改变父类的成员变量D.继承只能在同一个文件中实现6.在C语言中，实现多态的主要方式是（）。A.使用函数重载B.使用函数指针C.使用虚函数D.使用宏定义7.下列关于构造函数的描述中，正确的是（）。A.构造函数必须有返回值B.构造函数的名称与类名不同C.构造函数用于初始化对象D.构造函数可以被继承8.下列关于析构函数的描述中，正确的是（）。A.析构函数必须有参数B.析构函数的名称与类名相同，但以波浪号开头C.析构函数用于释放对象资源D.析构函数可以被重载9.在C语言中，以下哪个关键字用于表示公有访问权限（）。A.`private`B.`protected`C.`public`D.`static`10.在C语言中，以下哪个关键字用于表示静态成员（）。A.`virtual`B.`const`C.`static`D.`abstract`二、多选题1.下列关于面向对象编程的优点中，正确的是（）。A.提高代码的可维护性B.提高代码的执行效率C.提高代码的复用性D.提高代码的可扩展性2.下列关于类的成员中，正确的是（）。A.成员变量B.成员函数C.构造函数D.宏定义3.下列关于继承的性质中，正确的是（）。A.单继承B.多继承C.多态性D.覆盖4.下列关于多态的实现方式中，正确的是（）。A.函数重载B.函数指针C.虚函数D.运算符重载5.下列关于构造函数的调用中，正确的是（）。A.对象创建时自动调用B.可以在对象创建后手动调用C.必须在对象创建前调用D.调用次数有限制6.下列关于析构函数的调用中，正确的是（）。A.对象销毁时自动调用B.可以在对象销毁后手动调用C.必须在对象销毁前调用D.调用次数有限制7.下列关于访问控制关键字中，正确的是（）。A.`public`B.`private`C.`protected`D.`default`8.下列关于静态成员中，正确的是（）。A.静态成员属于类B.静态成员属于对象C.静态成员可以被对象调用D.静态成员只能通过类名调用9.下列关于友元函数中，正确的是（）。A.友元函数不是类的成员函数B.友元函数可以访问类的私有成员C.友元函数需要声明在类中D.友元函数会影响类的封装性10.下列关于虚函数中，正确的是（）。A.虚函数可以在基类中声明B.虚函数可以在派生类中重写C.虚函数必须返回值D.虚函数不能是静态成员三、填空题1.面向对象编程的三大基本特征是________、________和________。2.在C语言中，使用________关键字来定义类。3.类的成员变量可以分为________、________和________三种访问权限。4.继承可以分为________和________两种类型。5.多态性可以通过________和________两种方式来实现。6.构造函数的名称与________相同。7.析构函数的名称与________相同，但以________开头。8.静态成员属于________，可以通过________或________来访问。9.友元函数可以访问类的________成员。10.虚函数可以使派生类的方法覆盖基类的方法。四、简答题1.解释面向对象编程的概念及其主要特点。2.描述在C语言中如何定义一个类，包括类的成员变量和成员函数。3.解释封装的概念，并说明其在C语言中如何实现。4.描述继承的概念及其优点，并举例说明如何在C语言中实现单继承。5.解释多态的概念，并说明其在C语言中如何通过虚函数实现。6.描述构造函数和析构函数的作用，并举例说明如何在C语言中定义和使用它们。7.解释访问控制关键字的概念，并说明其在C语言中有哪些种类及其作用。8.描述静态成员的概念及其特点，并说明其在C语言中如何使用。9.解释友元函数的概念及其作用，并说明其在C语言中如何声明和使用。10.描述虚函数的概念及其作用，并说明如何在C语言中声明和实现虚函数。五、编程题1.定义一个名为`Person`的类，包含私有成员变量`name`和`age`，以及公有成员函数`setName`、`setAge`、`getName`和`getAge`。编写代码实现类的定义和成员函数的声明与实现。2.定义一个名为`Student`的类，继承自`Person`类，并添加一个私有成员变量`studentID`和一个公有成员函数`setStudentID`和`getStudentID`。编写代码实现类的定义和成员函数的声明与实现。3.在`Student`类中，重写`Person`类的`getName`函数，使其在输出姓名时加上"Student"。编写代码实现函数的重写。4.编写代码创建一个`Student`对象，设置其姓名、年龄和学号，并分别调用`getName`、`getAge`和`getStudentID`函数输出相关信息。5.定义一个名为`Rectangle`的类，包含私有成员变量`width`和`height`，以及公有成员函数`setDimensions`、`getArea`和`getPerimeter`。编写代码实现类的定义和成员函数的声明与实现。6.在`Rectangle`类中，重写`getArea`函数，使其能够计算并返回矩形的面积。编写代码实现函数的重写。7.编写代码创建一个`Rectangle`对象，设置其宽度和高度，并分别调用`getArea`和`getPerimeter`函数输出矩形的面积和周长。8.定义一个名为`Car`的类，包含私有成员变量`brand`、`model`和`year`，以及公有成员函数`setCarInfo`、`getBrand`、`getModel`和`getYear`。编写代码实现类的定义和成员函数的声明与实现。9.在`Car`类中，重写`getBrand`函数，使其在输出品牌时加上"Car"。编写代码实现函数的重写。10.编写代码创建一个`Car`对象，设置其品牌、型号和年份，并分别调用`getBrand`、`getModel`和`getYear`函数输出相关信息。试卷答案一、选择题1.B解析：面向对象编程是一种基于对象和类的编程范式，通过封装、继承和多态来实现代码的模块化、复用性和可扩展性。选项A错误，面向对象编程是面向过程的对立面。选项C错误，面向对象编程更注重代码的结构和可维护性，不一定强调执行效率。选项D错误，面向对象编程适用于各种规模的项目。2.C解析：封装是将数据（成员变量）和操作数据的方法（成员函数）绑定在一起，并限制外部直接访问数据，主要通过结构体和访问控制关键字（如`public`、`private`、`protected`）来实现。选项A错误，宏定义是预处理器功能，不涉及封装。选项B错误，函数是代码块，可以封装逻辑，但不是实现封装的主要方式。选项D错误，指针是C语言的重要特性，可用于实现动态内存管理和指针运算，但不直接用于封装。3.B解析：类是面向对象编程的基本单元，是描述对象属性（成员变量）和行为（成员函数）的模板。对象是类的实例。选项A错误，对象是类的实例。选项C错误，`class`是C++中的关键字，C语言中没有直接的类关键字，但可以通过结构体和函数指针模拟。选项D错误，类通常包含成员变量。4.C解析：在C语言中，通常使用动态内存分配（`malloc`）来创建对象，并使用指针来管理对象。选项A是定义结构体的方式。选项B是定义结构体变量的方式。选项D是初始化结构体变量的方式。5.B解析：继承是实现代码复用的机制，允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法。选项A错误，C语言中通常只支持单继承（一个子类只能有一个直接父类）。选项C错误，继承不会改变父类的成员变量。选项D错误，继承可以在不同的文件中实现，只要遵循C语言的编译和链接规则。6.C解析：多态是指同一个方法调用在不同对象上有不同的实现效果。在C语言中，主要通过虚函数（`virtual`函数，C++中）或函数指针/函数表来实现类似的多态效果。选项A和B可以实现方法的重载或不同的调用方式，但不是多态。选项D错误，宏定义是文本替换，不涉及运行时的多态。7.C解析：构造函数是特殊的成员函数，用于在创建对象时初始化对象的状态。它没有返回值，名称与类名相同。选项A错误，构造函数没有返回值。选项B错误，构造函数名称与类名相同。选项D错误，构造函数可以被继承，子类可以定义自己的构造函数。8.B解析：析构函数是特殊的成员函数，用于在对象销毁时执行清理工作（如释放资源）。它没有参数，名称与类名相同，但以波浪号（`~`）开头。选项A错误，析构函数没有返回值。选项C错误，析构函数用于释放资源，不是初始化。选项D错误，析构函数可以被重写。9.C解析：`public`是C++中的访问控制关键字，表示公有成员，可以被类外代码访问。选项A、B、D是其他访问控制关键字或错误关键字。10.C解析：`static`是C语言中的关键字，用于定义静态成员。静态成员属于类本身，而非具体的对象实例。静态成员函数也可以通过`static`关键字声明。选项A、B、D是其他关键字或错误用法。二、多选题1.A,C,D解析：面向对象编程的优点包括提高代码的可维护性（通过封装和模块化）、提高代码的复用性（通过继承）和提高代码的可扩展性（通过继承和多态）。选项B错误，面向过程编程可能更注重执行效率，但面向对象编程也关注效率，只是侧重点不同。2.A,B,C解析：类通常包含成员变量（用于存储数据）和成员函数（用于操作数据或行为）。选项D宏定义是C语言预处理器的功能，不属于类的组成部分。3.A,B,D解析：继承可以分为单继承（一个子类只有一个直接父类）和多继承（一个子类可以有多个直接父类，C语言通常不支持多继承）。选项C多态性是面向对象的一个特性，不是继承的类型。选项D覆盖（Overriding）是指子类重新实现父类的虚函数，是继承的一种表现形式。4.B,C解析：在C语言中，实现类似多态的主要方式是使用函数指针。可以通过将函数指针作为成员变量或传递函数指针来实现运行时绑定。选项A函数重载是C++的特性。选项D运算符重载也是C++的特性。5.A,B解析：构造函数在创建对象时自动调用，用于初始化对象。可以在对象创建过程中显式调用构造函数（例如通过placement`new`，但这是C++特性，C语言通常隐式调用）。选项C错误，构造函数在对象创建时调用。选项D错误，构造函数调用次数取决于对象创建和销毁的次数，没有固定限制。6.A解析：析构函数在对象销毁时自动调用，用于执行清理工作。选项B、C错误，析构函数是自动调用的。选项D错误，析构函数调用次数通常与对象创建和销毁次数相关，没有固定限制。7.A,B,C解析：访问控制关键字用于限制成员的访问权限。C语言中有`public`（通常对应`extern`或`public`），`private`（通常对应`static`配合限制访问），`protected`（C++特有，通常对应`private`但允许子类访问）。C语言标准本身没有明确的`protected`，但可以通过`private`和友元组合模拟。这里按C++的划分列出。严格来说，C语言只有`public`（全局可见）和`private`（文件内部可见，通过`static`实现）的概念，但题目可能基于C++的术语。8.A,C,D解析：静态成员属于类本身，而不是任何特定的对象实例。静态成员可以通过类名直接访问（`ClassName::staticMember`），也可以通过对象实例访问（`object.staticMember`）。选项B错误，静态成员不属于对象实例。9.A,B,D解析：友元函数不是类的成员函数，但它可以访问类的私有和保护成员。友元函数需要在使用前在类中声明（函数原型）。引入友元函数会降低类的封装性，因为私有和保护成员对友元函数可见。选项C错误，友元函数不需要在类中定义实现，只需要声明。10.A,B解析：虚函数（C++概念）可以在基类中声明（使用`virtual`关键字），并在派生类中重写（使用与基类相同签名但可能不同的实现）。选项C错误，虚函数可以返回任何类型（包括`void`）。选项D错误，虚函数不能是静态成员（静态成员属于类，与对象实例无关，无法实现多态调用）。三、填空题1.封装，继承，多态解析：封装、继承和多态是面向对象编程的三大基本特征。封装隐藏实现细节，继承实现代码复用，多态实现接口统一。2.`class`解析：在C++中，使用`class`关键字来定义类。C语言本身没有`class`关键字，但可以通过`struct`结合函数指针等方式模拟类的行为。3.公有（`public`），私有（`private`），保护（`protected`）解析：类成员变量的访问权限通常分为公有、私有和保护三种。公有成员可以被类外代码访问，私有成员只能被类内代码访问，保护成员可以被类内代码和子类访问（C++术语，C语言有类似概念但实现方式不同）。4.单继承，多继承（C++中）解析：继承分为单继承（一个子类只有一个直接父类）和多继承（一个子类可以有多个直接父类）。C语言标准库不支持多继承，但可以通过组合和指针模拟。5.函数指针，虚函数（C++中）解析：在C语言中，主要使用函数指针来实现类似多态的行为（运行时绑定）。在C++中，使用`virtual`关键字声明虚函数来实现多态。6.类名解析：构造函数的名称必须与类的名称完全相同。7.类名，波浪号（`~`）解析：析构函数的名称由类的名称加上一个前缀波浪号（`~`）组成，例如`~ClassName()`。8.类，类名，对象名解析：静态成员属于类本身，不属于任何对象实例。可以通过类名直接访问（`ClassName::staticMember`），也可以通过对象名访问（`object.staticMember`，只要对象存在）。9.私有和保护解析：友元函数可以访问类的私有和保护成员，这是友元函数的主要作用之一，因为它不被视为类的一部分，可以绕过访问控制。10.虚函数（C++中）解析：虚函数（`virtual`函数，C++中）允许派生类提供与基类同名且相同签名的函数的不同实现。当通过基类指针或引用调用虚函数时，会根据实际指向的对象类型调用相应的版本，从而实现多态。四、简答题1.面向对象编程（Object-OrientedProgramming,OOP）是一种基于“对象”和“类”的编程范式。它将数据（属性）和操作数据的方法（行为）封装在一起，形成一个对象。通过类来定义对象的模板，对象是类的实例。OOP的主要特点包括封装、继承和多态。封装隐藏对象的内部细节，只暴露必要的接口；继承允许一个类继承另一个类的属性和方法，实现代码复用和扩展；多态允许不同类的对象对同一消息做出不同的响应，提高代码的灵活性和可扩展性。2.在C语言中，定义一个类通常通过定义一个`struct`结构体，并包含函数指针作为成员函数。例如：```cstructPerson{char*name;intage;void(*setName)(structPerson*,constchar*);int(*setAge)(structPerson*,int);constchar*(*getName)(conststructPerson*);int(*getAge)(conststructPerson*);};```然后实现这些函数指针指向的函数，并创建`Person`类型的变量（对象）并初始化函数指针。这种方式模拟了C++中的类，但需要手动管理函数指针和对象生命周期。3.封装是指将数据（成员变量）和操作数据的方法（成员函数）绑定在一起，形成一个统一的整体，并限制外部直接访问数据，通过接口提供访问和修改数据的方法。在C语言中，通过`struct`结构体来组织数据和函数指针，并使用文件作用域（`static`）或访问控制（模拟，因为C语言没有内置的访问控制关键字）来限制数据访问。例如，将成员变量声明为`static`，并通过函数指针提供的公有函数（接口）来访问和修改它们。4.继承是实现代码复用的机制，允许一个类（子类/派生类）继承另一个类（父类/基类）的属性和方法。优点包括减少代码重复、提高代码可维护性和可扩展性。在C语言中，可以通过组合（将父类对象作为成员变量）和函数指针（模拟虚函数）来实现类似继承的效果。例如，定义一个基类结构体和派生类结构体，派生类包含基类结构体的实例，并通过函数指针调用基类方法。单继承是指一个子类只有一个直接父类。5.多态是指同一个方法调用在不同对象上有不同的实现效果。它允许使用统一的接口来处理不同类型的对象，提高代码的灵活性和可扩展性。在C语言中，主要通过函数指针实现类似的多态。可以定义一个函数指针类型，并在不同类中实现同名函数，通过将函数指针赋值给该类型，调用函数指针时根据指针指向的实际函数执行不同的代码。C++中通过虚函数机制更直接地实现多态。6.构造函数是在创建对象时自动调用的特殊成员函数，用于初始化对象的状态（成员变量）。它没有返回值，名称与类名相同。析构函数是在对象销毁时自动调用的特殊成员函数，用于执行清理工作（如释放动态分配的内存）。它没有参数，名称与类名相同，但以波浪号（`~`）开头。在C语言中，通过在`struct`中定义函数指针（模拟构造函数和析构函数），并在创建和销毁对象时（通过`malloc`和`free`）手动调用这些函数指针来模拟构造函数和析构函数的行为。7.访问控制关键字用于限制类成员（成员变量和成员函数）的访问权限。在C语言中，虽然没有标准的`public`、`private`、`protected`关键字，但可以通过`static`和文件作用域（`extern`或无声明）来模拟访问控制。`static`可以限制成员仅在定义它的文件内部可见（类似`private`）。全局声明的成员或函数默认是全局可见的（类似`public`）。C++提供了更明确的访问控制机制。8.静态成员属于类本身，而不是任何特定的对象实例。静态成员在所有对象之间共享同一份内存。静态成员可以通过类名直接访问（`ClassName::staticMember`），也可以通过对象名访问（`object.staticMember`，只要对象存在）。静态成员函数不能访问非静态成员（除非它们也是静态的），只能访问静态成员。静态成员主要用于存储类级别的数据或提供不依赖于对象实例的函数。在C语言中，通过在`struct`中声明`static`变量或函数指针来模拟静态成员。9.友元函数是类外部定义的函数，但它被声明在类的内部，并且可以访问该类的私有和保护成员。友元关系是单向的，不是继承的。引入友元函数会降低类的封装性，因为私有和保护成员对友元函数可见。在C语言中，可以通过在类中声明函数指针，并在类外定义对应的函数，并确保这些函数通过类提供的接口（公有成员函数）来访问私有数据，来模拟友元函数的效果。10.虚函数（`virtual`函数，C++中）是允许派生类提供与基类同名且相同签名的函数的不同实现的成员函数。当通过基类指针或引用调用虚函数时，会根据实际指向的对象类型调用相应的版本，从而实现多态。在C语言中，可以通过定义函数指针类型的成员变量，并在不同类中实现同名函数，通过函数指针调用函数来模拟虚函数的行为，实现运行时多态。五、编程题1.代码实现：```c#include<stdio.h>#include<stdlib.h>#include<string.h>structPerson{char*name;intage;void(*setName)(structPerson*,constchar*);int(*setAge)(structPerson*,int);constchar*(*getName)(conststructPerson*);int(*getAge)(conststructPerson*);};voidPerson_setName(structPerson*p,constchar*n){if(p&&n){free(p->name);p->name=strdup(n);}}intPerson_setAge(structPerson*p,inta){if(p){p->age=a;return0;}return-1;}constchar*Person_getName(conststructPerson*p){returnp?p->name:NULL;}intPerson_getAge(conststructPerson*p){returnp?p->age:-1;}//Exampleusage(constructors/destructorsaresimulated)structPerson*Person_new(constchar*n,inta){structPerson*p=malloc(sizeof(structPerson));if(p){p->name=NULL;p->age=0;p->setName=Person_setName;p->setAge=Person_setAge;p->getName=Person_getName;p->getAge=Person_getAge;p->setName(p,n);p->setAge(p,a);}returnp;}voidPerson_delete(structPerson*p){if(p){free(p->name);free(p);}}//Testcodeintmain(){structPersonperson=Person_new("Alice",30);printf("Name:%s,Age:%d\n",person.getName(&person),person.getAge(&person));person.setName(&person,"Bob");person.setAge(&person,32);printf("Name:%s,Age:%d\n",person.getName(&person),person.getAge(&person));Person_delete(&person);return0;}```2.代码实现：```c#include<stdio.h>#include<stdlib.h>#include<string.h>structPerson{char*name;intage;void(*setName)(structPerson*,constchar*);int(*setAge)(structPerson*,int);constchar*(*getName)(conststructPerson*);int(*getAge)(conststructPerson*);};//...(Person_setName,Person_setAge,Person_getName,Person_getAge,Person_new,Person_deleteasabove)...structStudent{structPersonbase;//Simulatinginheritancewithcompositionchar*studentID;void(*setStudentID)(structStudent*,constchar*);constchar*(*getStudentID)(conststructStudent*);};voidStudent_setStudentID(structStudent*s,constchar*id){if(s&&id){free(s->studentID);s->studentID=strdup(id);}}constchar*Student_getStudentID(conststructStudent*s){returns?s->studentID:NULL;}//Simulatingconstructor/destructorforStudentstructStudent*Student_new(constchar*n,inta,constchar*id){structStudent*s=malloc(sizeof(structStudent));if(s){s->base.setName=Person_setName;s->base.setAge=Person_setAge;s->base.getName=Person_getName;s->base.getAge=Person_getAge;s->base.setName(&s->base,n);s->base.setAge(&s->base,a);s->setStudentID=Student_setStudentID;s->getStudentID=Student_getStudentID;s->setStudentID(s,id);}returns;}voidStudent_delete(structStudent*s){if(s){free(s->);free(s->studentID);free(s);}}//Testcodeintmain(){structStudentstudent=Student_new("Charlie",20,"S12345");printf("Name:%s,Age:%d,StudentID:%s\n",student.base.getName(&student.base),student.base.getAge(&student.base),student.getStudentID(&student));student.base.setName(&student.base,"David");student.base.setAge(&student.base,22);student.setStudentID(&student,"S54321");printf("Name:%s,Age:%d,StudentID:%s\n",student.base.getName(&student.base),student.base.getAge(&student.base),student.getStudentID(&student));Student_delete(&student);return0;}```3.代码实现（在Student类中重写getName）：```cconstchar*Student_getName(conststructStudent*s){if(s){//Callthebaseclass'sgetNametogettheoriginalnameconstchar*baseName=s->base.getName(&s->base);//Allocatememoryforthenewnameandconcatenatechar*newName=malloc(strlen(baseName)+strlen("Student")+1);if(newName){strcpy(newName,baseName);strcat(newName,"Student");returnnewName;//Returnanewstring}returnbaseName;//Returnoriginalifnewnameallocationfails}returnNULL;}```4.代码实现（使用Person和Student）：```c#include<stdio.h>#include<stdlib.h>#include<string.h>//...(includePerson_new,Person_delete,Person_setName,Person_setAge,Person_getName,Person_getAge)...//...(includeStudent_new,Student_delete,Student_setStudentID,Student_getStudentID,Student_getName)...intmain(){//CreateaPersonobjectstructPerson*person=Person_new("Eve",25);if(!person)return1;printf("Person-Name:%s,Age:%d\n",person->getName(person),person->getAge(person));person->setName(person,"Grace");person->setAge(person,27);printf("Person-Name:%s,Age:%d\n",person->getName(person),person->getAge(person));Person_delete(person);//CreateaStudentobjectstructStudent*student=Student_new("Frank",22,"S67890");if(!student)return1;printf("Student-Name:%s,Age:%d,StudentID:%s\n",student->base.getName(&student->base),student->base.getAge(&student->base),student->getStudentID(student));student->base.setName(&student->base,"Henry");student->base.setAge(&student->base,24);student->setStudentID(student,"S123456");printf("Student-Name:%s,Age:%d,StudentID:%s\n",student->base.getName(&student->base),student->base.getAge(&student->base),student->getStudentID(student));Student_delete(student);return0;}```5.代码实现：```c#include<stdio.h>#include<stdlib.h>structRectangle{doublewidth;doubleheight;double(*getArea)(conststructRectangle*);double(*getPerimeter)(conststructRectangle*);};doubleRectangle_getArea(conststructRectangle*r){returnr?r->width*r->height:0.0;}doubleRectangle_getPerimeter(conststructRectangle*r){returnr?2*(r->width+r->height):0.0;}//Simulatingconstructor/destructorstructRectangle*Rectangle_new(doublew,doubleh){structRectangle*r=malloc(sizeof(structRectangle));if(r){r->width=w;r->height=h;r->getArea=Rectangle_getArea;r->getPerimeter=Rectangle_getPerimeter;}returnr;}voidRectangle_delete(structRectangle*r){free(r);}//Testcodeintmain(){structRectanglerect=Rectangle_new(5.0,3.0);if(!rect.getArea)return1;printf("Area:%.2f,Perimeter:%.2f\n",rect.getArea(&rect),rect.getPerimeter(&rect));Rectangle_delete(&rect);return0;}```6.代码实现（在Rectangle类中重写getArea）：```cdoubleRectangle_getArea(conststructRectangle*r){returnr?r->width*r->height:0.0;}```7.代码实现（使用Rectangle）：```c#include<stdio.h>#include<stdlib.h>//...(includeRectangle_new,Rectangle_delete,Rectangle_getArea,Rectangle_getPerimeter)...intmain(){structRectanglerect=Rectangle_new(7.0,4.0);if(!rect.getArea)return1;printf("Area:%.2f,Perimeter:%.2f\n",rect.getArea(&rect),rect.getPerimeter(&rect));//Changedimensionsrect.width=6.0;rect.height=5.0;printf("Area:%.2f,Perimeter:%.2f\n",rect.getArea(&rect),rect.getPerimeter(&rect));Rectangle_delete(&rect);return0;}```8.代码实现：```c#include<stdio.h>#include<stdlib.h>#include<string.h>structCar{char*brand;char*model;intyear;constchar*(*getBrand)(conststructCar*);constchar*(*getModel)(conststructCar*);int(*getYear)(conststructCar*);};constchar*Car_getBrand(conststructCar*c){returnc?c->brand:NULL;}constchar*Car_getModel(conststructCar*c){returnc?c->model:NULL;}intCar_getYear(conststructCar*c){returnc?c->year:0;}//Simulatingconstructor/destructorstructCar*Car_new(constchar*b,constchar*m,int