住房与住房建设部网站,营销型企业网站优点,单位网站平台建设汇报,培训机构哪家好目录
引言
正文
01-类和对象简介
02-封装简介
03-封装的意义
04-封装案例之设计学生类
05-封装的权限控制
06-struct和class的区别
07-成员属性设置为私有
08-封装案例1-设计立方体
09-封装案例2-判断点和圆的关系
总结 引言 在C中#xff0c;…目录
引言
正文
01-类和对象简介
02-封装简介
03-封装的意义
04-封装案例之设计学生类
05-封装的权限控制
06-struct和class的区别
07-成员属性设置为私有
08-封装案例1-设计立方体
09-封装案例2-判断点和圆的关系
总结 引言 在C中类和对象是面向对象编程的基本概念而封装则是面向对象编程的三大特征之一包括封装、继承和多态。封装是指将数据和操作数据的方法封装在类中通过类的访问控制来保护数据只能通过类的接口进行访问和操作。 封装的原理是通过将数据和操作数据的方法封装在类中然后通过访问控制来保护数据的安全性和合理性。具体原理包括以下几点 数据隐藏封装通过将数据成员声明为私有(private)的外部无法直接访问这些数据成员只能通过类的公有(public)接口来访问和修改数据从而隐藏了类的内部实现细节。 访问控制通过类的访问控制修饰符(private、public、protected)来限制对数据成员和成员函数的访问权限。私有成员只能在类的内部访问公有成员可以在类的外部访问受保护成员可以在子类中访问。 封装方法类中定义的成员函数作为对数据成员的操作方法外部用户只能通过这些成员函数来间接访问和修改数据成员确保数据操作的合理性和安全性。 数据保护封装能够保护数据防止外部的非法访问和意外修改数据通过类的封装将用户和类的实现细节隔离开来。 代码复用封装将数据和方法封装在一起提高了代码的重用性可以在不同的地方复用类的功能减少重复编写代码的工作
正文
01-类和对象简介 在C中类和对象是面向对象编程的基本概念是实现封装、继承和多态的重要手段。下面详细解释一下类和对象的概念以及它们在C中的应用 1类 a、类是用户定义的数据类型用来描述对象的属性和行为。通过类可以封装数据和方法定义了对象的状态和行为。 b、类的成员包括数据成员和成员函数数据成员用来描述对象的属性成员函数用来描述对象的行为。类的成员可以设置为私有(private)、公有(public)或保护(protected)。 c、类的定义通过关键字class加上类名来声明类体内包含类的数据成员和成员函数通常在类定义中把数据成员设置为私有成员函数设置为公有。 2对象 a、对象是类的具体实例是内存中的一个区域包含了类的数据成员的实际值。同一个类可以创建出多个不同的对象。 b、使用对象可以调用类的成员函数来操作对象的数据通过对象访问和修改对象的数据。 3类和对象的关系 a、类是对象的模板描述了对象的属性和行为的定义。通过类的构造函数来创建对象。 b、对象是类的实例是根据类定义出来的实际存在的实例实际使用中通过对象来操作数据和方法。 代码示例如下在示例代码中定义了一个Person类包含了姓名和年龄两个数据成员以及修改数据成员和展示信息的成员函数。通过创建Person类的对象p1可以设置对象的姓名和年龄并且展示对象的信息。
#include iostream
using namespace std;class Person {
private:string name;int age;public:void setName(string n) {name n;}void setAge(int a) {age a;}void displayInfo() {cout Name: name endl;cout Age: age endl;}
};int main() {Person p1;p1.setName(Alice);p1.setAge(25);p1.displayInfo();return 0;
}
02-封装简介 在C中封装是面向对象编程的三大特征之一包括封装、继承和多态。 封装的作用 a、数据隐藏 封装可以隐藏类的内部实现细节用户只需了解如何使用类的公共接口而不需要了解其内部实现。 b、数据保护 通过访问控制对数据进行限制只能通过类的方法去访问和修改数据保证数据的安全合理。 c、代码复用 封装将数据和操作数据的方法组合在一起提高了代码的重用性可以在不同的地方复用类的功能。 d、降低耦合度 封装使得类之间的耦合度降低各个类之间通过接口进行通信方便维护和扩展。 示例代码如下在代码中定义了一个Car类其中brand和year是私有的数据成员通过公有的成员函数进行访问和修改。这样就实现了数据的封装外部用户只能通过类的接口来操作数据无法直接访问或修改私有数据成员。这保证了数据安全性和代码的健壮性。
#include iostream
#include string
using namespace std;class Car {
private:string brand;int year;public:Car(string b, int y) {brand b;year y;}string getBrand() {return brand;}void setBrand(string b) {brand b;}int getYear() {return year;}void setYear(int y) {year y;}
};int main() {Car myCar(Toyota, 2020);cout Brand: myCar.getBrand() endl;cout Year: myCar.getYear() endl;myCar.setBrand(Honda);myCar.setYear(2022);cout New Brand: myCar.getBrand() endl;cout New Year: myCar.getYear() endl;return 0;
}
03-封装的意义 封装作为面向对象编程的重要特征具有以下意义 a、隐藏内部实现细节封装可以隐藏类的内部实现细节只暴露给外部用户必要的接口无需了解类的具体实现细节从而降低了复杂性提高了代码的可维护性。 b、保护数据安全通过封装可以将数据成员设置为私有(private)只允许通过类的公共接口来访问和修改数据避免了外部直接对数据的误操作和破坏。 c、封装行为和数据封装将数据和操作数据的方法封装在一起使得对象不仅具有数据的属性还具备一系列操作自身数据的方法实现了数据与行为的整合。 d、简化复杂性封装使得编程人员可以将复杂的问题拆解为多个小问题进行处理降低了维护和调试的难度提高了代码的可读性。 e、提高代码的可重用性封装将相关的数据和行为封装成类可以在不同的程序中多次使用避免了代码重复编写提高了代码的重用性。 下面给出一个具体的代码分析示例在代码中定义了一个Circle类表示圆私有数据成员radius被封装起来只能通过公有成员函数来访问和修改。getRadius和setRadius分别用于获取和设置圆的半径通过setRadius方法限制了半径不能为负数。这样封装保护了数据的合法性和安全性避免了不合理的操作。
#include iostream
using namespace std;class Circle {
private:double radius;public:Circle(double r) : radius(r) {}double getRadius() {return radius;}void setRadius(double r) {if (r 0) {radius r;} else {cout Invalid radius value! endl;}}double getArea() {return 3.14159 * radius * radius;}
};int main() {Circle c1(5.0);cout Radius: c1.getRadius() endl;cout Area: c1.getArea() endl;c1.setRadius(-2.0); // 尝试设置负数半径会触发错误输出return 0;
} 下面给出具体代码进行分析函数封装的应用过程这个示例演示了如何设计一个圆类 Circle并使用该类计算圆的周长代码解释如下 1类定义 a、使用 class关键字定义了一个类 Circle其中包含了公共部分和私有部分。 b、公共部分包括一个整型数据成员 m_r表示圆的半径以及一个成员函数calculateZC()用来计算圆的周长。 c、私有部分目前为空因此没有在示例中定义任何私有成员。 2主函数 a、在 main() 函数中创建了一个名为 c1的 Circle类型的对象。 b、将对象的半径设置为 10然后调用 calculateZC() 成员函数计算圆的周长并将结果输出到控制台。 3作用分析 a、这个示例展示了如何使用类来封装数据和行为并通过对象来访问这些数据和行为。 b、通过定义一个圆类将计算周长的方法封装在类的内部使得外部用户无需了解具体的计算过程只需调用类的方法即可获取结果。 类的封装性使得代码更加模块化和易于维护提高了代码的可读性和可维护性。
#includeiostream
using namespace std;const double PI 3.14; // 使用const修饰变量设置PI的常量// 设计一个圆类求圆的周长
// 圆求周长的公式 2 * PI *半径// 设计类和结构体很像需要class关键字class就代表一个类类后面紧跟着的就是类的名称
class Circle // Circle是一个自定义的名称见名知意
{// 首先设定访问权限分为公共权限和私有权限// 公共权限
public:// 属性// 半径int m_r;// 行为// 获取圆的周长 这里就应该使用函数来代表double calculateZC(){return 2 * PI * m_r;}// 私有权限
private:
};int main()
{// 现在有了一个圆的对象但是还没有一个具体的圆因此类似结构体一样可以定义一个具体的圆的变量名(对象)Circle c1;c1.m_r 10;cout 圆的周长 c1.calculateZC() endl;system(pause);return 0;
} 示例运行结果如下图所示 04-封装案例之设计学生类 接下来进行一个封装案例的编写从实战中分析封装的作用 注一些专业术语 类中的属性和行为我们统一称为 成员 属性 又被称为 成员属性或者成员变量 行为 成员函数或者成员方法 因为行为一般定义的都是函数和方法 下面这个示例演示了一个简单的学生类 Student的设计以及如何创建学生对象、设置学生信息和展示学生信息。代码具体分析如下 1类定义 Student类包含了两个公共属性 m_Name姓名和 m_Id学号以及三个行为showStudent() 用于展示学生姓名和学号setName() 用于设置学生的姓名setId() 用于设置学生的学号。 2主函数 在 main() 函数中首先创建了一个学生对象 s1通过用 setName() 和 setId() 函数为该学生对象设置姓名和学号然后调用 showStudent() 函数展示学生信息。 随后创建了另一个学生对象 s2直接为该学生对象的属性赋值不使用设置函数然后调用 showStudent() 函数展示学生信息。 3作用分析 通过设计学生类封装了学生的属性和展示学生信息的行为实现了数据与行为的整合。 通过实例化学生对象可以为不同的学生对象设置不同的信息实现了对学生数据的管理和操作。 通过类的成员函数实现了对学生信息的设置和展示对外部用户隐藏了类的具体实现细节。
#includeiostream
using namespace std;
#include string// 设计学生类
class Student
{
public: // 公共权限// 属性string m_Name; // 姓名int m_Id; // 学号// 行为// 显示学生姓名和学号void showStudent(){cout 姓名 m_Name 学号 m_Id endl;}// 当然也可以将学生姓名的也作为一个行为输入void setName(string name){m_Name name;}// 当然也可以将学生学号的也作为一个行为输入void setId(int Id){m_Id Id;}};int main()
{// 下面就创建一个具体的学生也叫实例化对象Student s1;
// s1.m_Name 张三;s1.setName(张三);s1.setId(1);// 显示学生s1.showStudent(); // 直接调用类里面的这个函数即可// 也可以继续在创建一个学生Student s2;s2.m_Name 李四;s2.m_Id 2;s2.showStudent();system(pause);return 0;
} 示例运行结果如下图所示 05-封装的权限控制 封装的权限控制是指在面向对象编程中通过类的访问修饰符public、private、protected来限定类的成员对外部的可见性和可操作性。具体解释如下 public权限 a、公共权限的成员函数和成员变量可以被任何函数访问即外部可以通过类的对象直接访问和操作这些成员。 b、公共成员通常用于定义类的接口提供对外的操作接口外部用户可以通过这些接口来访问和操作类的数据。 private权限 a、私有权限的成员函数和成员变量只能在当前类的成员函数中访问和操作外部无法直接访问。 b、私有成员通常用于封装类的内部实现细节保护类的数据并确保数据的安全性和不变性。 protected权限 a、受保护权限的成员函数和成员变量可以被当前类和子类派生类的成员函数访问但是外部无法直接访问。 b、受保护成员通常用于实现类的继承和派生子类可以继承和重用受保护成员。 总结如下// 公共权限 public 成员 类内可以访问类外也可以访问 // 保护权限 protected 成员 类内可以访问类外不可以访问 // 私有权限 private 成员 类内可以访问类外不可以访问。 下面是一个具体的代码示例在示例中Car类中的model和 price成员变量被设置为私有(private)权限只能通过公共成员函数进行访问和修改。外部无法直接访问和修改这些私有成员变量保护了车辆对象的数据安全性。这样封装通过权限控制实现了数据的保护和隐藏确保了类的封装性和数据的完整性。
#include iostream
using namespace std;class Car {
private:string model; // 私有成员变量double price; // 私有成员变量public:void setModel(string m) { // 公共成员函数model m;}string getModel() { // 公共成员函数return model;}void setPrice(double p) { // 公共成员函数if (p 0) {price p;} else {cout Invalid price value! endl;}}double getPrice() { // 公共成员函数return price;}
};int main() {Car myCar;myCar.setModel(Toyota);myCar.setPrice(25000);cout Car Model: myCar.getModel() endl;cout Car Price: $ myCar.getPrice() endl;// 以下代码会编译失败因为 model 和 price 是私有成员// cout myCar.model endl;// myCar.price 20000;return 0;
} 下面这个示例展示了类中成员变量在不同权限修饰符下的访问控制包括公共(public)、保护(protected)和私有(private)权限。代码具体分析如下 1类定义 a、Person类包含了三个成员变量m_Name姓名、m_Car汽车、m_Password银行卡密码分别使用了不同的权限修饰符公共、保护和私有。 b、func() 是一个公共成员函数可以在外部通过类的实例化对象调用用来演示在成员函数中访问不同权限下的成员变量。 2权限控制 a、公共权限的成员变量 m_Name可以在类外部通过对象直接访问。 b、保护权限的成员变量 m_Car只能在当前类及其子类中访问无法在类外部直接访问。 c、私有权限的成员变量 m_Password只能在当前类的成员函数中访问外部无法直接访问。 3主函数 a、在 main() 函main数中创建了一个 Person 类的实例 p1。 b、尝试在外部通过对象访问不同权限下的成员变量结果显示了公共成员变量可以访问而保护和私有成员变量无法直接访问。 c、通过调用 func() 成员函数实现了在类内部访问不同权限下的成员变量因为成员函数可以访问类的所有成员。
#includeiostream
using namespace std;
#include stringclass Person
{
public: string m_Name;// 姓名protected:// 保护权限string m_Car; // 汽车private:// 私有权限int m_Password; // 银行卡密码
// 测试一下是否可以类内访问public: // 当使用public 时是可以访问到这个函数的void func() // 此时编译是没有任何问题的{m_Name 张三;m_Car 宝马;m_Password 12345;}
};int main()
{Person p1;p1.m_Name 李四; // 这里可以访问
// p1.m_Car 奔驰; // 无法访问 protected 成员(在“Person”类中声明)在编译时将会报错
// p1.m_Password 123; // 无法访问 protected 成员(在“Person”类中声明)在编译时将会报错// func(); 这里直接调用函数肯定是无法运行的因为这个函数在Person类中只能使用实例化对象 p1 调用 p1.func();system(pause);return 0;
}
06-struct和class的区别 对于 C 中的struct和 class时主要的区别在于默认的访问权限也称为数据封装性以及成员函数的默认继承属性。具体解释如下 1默认访问权限 a、对于 struct其默认访问权限为公共public在 struct中定义的数据成员和成员函数可以被外部直接访问和操作。 b、对于class其默认访问权限为私有private在 class中定义的成员通常是私有的需要通过公共的成员函数来访问和操作数据。 2默认继承属性 a、在继承方面与 struct相比class拥有默认的私有继承private。这意味着从 class继承的成员在派生类中默认为私有成员无法直接访问。 b、而从 struct继承的成员在派生类中默认为公共成员可以直接访问和操作。 下面是一个具体的代码示例在这个示例中我们可以看到 StudentStruct使用了 struct定义可以直接访问成员变量 name和 id而 StudentClass使用了 class定义需要通过公共函数来访问成员变量 name和 id。这展示了 struct和 class的默认访问权限和默认继承属性的不同之处。
#include iostream
using namespace std;// 使用 struct 定义学生结构体
struct StudentStruct {string name;int id;
};// 使用 class 定义学生类
class StudentClass {
public:string name;int id;
};int main() {// struct 可直接访问成员变量StudentStruct s1;s1.name Alice;s1.id 123;// class 需要通过公共函数访问成员变量StudentClass s2;s2.name Bob;s2.id 456;cout Student using struct: s1.name s1.id endl;cout Student using class: s2.name s2.id endl;return 0;
} 下面这个示例展示了 class和 struct在默认访问权限上的区别代码具体分析如下 1类定义 a、C1是一个类(class)定义了一个公共成员变量 m_A。在类中默认的成员访问权限是私有(private)所以外部无法直接访问 m_A。 b、C2是一个结构体(struct)同样定义了一个成员变量 m_A。在结构体中默认的成员访问权限是公共(public)所以外部可以直接访问 m_A。 2主函数 a、在 main() 函数中尝试实例化类 C1和结构体 C2的对象 c1和 c2。 b、由于 C1类的默认访问权限是私有所以在外部无法直接访问类的成员变量 m_A导致编译错误。 c、相反结构体 C2的成员变量 m_A默认为公共可以直接在外部访问和操作。
#includeiostream
using namespace std;
#include stringclass C1
{
public:int m_A; // 默认权限是私有的
};
struct C2
{int m_A; // 默认是公有的
}; int main()
{// struct和class的区别// struct的默认访问权限是公有的// class的默认访问权限是私有的C1 c1;
// c1.m_A 100; //这里无法执行无法访问C2 c2;c2.m_A 100;system(pause);return 0;
}
07-成员属性设置为私有 当将类中的成员属性设置为私有(private)时意味着这些属性只能在该类的成员函数中直接访问外部代码无法直接访问或修改这些私有属性。通过将属性设置为私有可以增强数据的封装性和安全性防止外部代码直接操作敏感数据。只能通过类的公共函数成员函数来间接访问或修改私有属性从而实现对数据的控制和保护 以下是使用私有成员属性的具体代码示例 在这个示例中Person类中的 name和 age属性被设置为私有属性。外部代码无法直接访问 name和 age而是通过公共函数 setName和 setAge来间接操作这些私有属性。这样可以确保数据安全和逻辑正确性。 通过设置成员属性为私有类的实现细节被隐藏只有通过提供的接口成员函数来访问数据从而实现更好的封装性和安全性。
#include iostream
using namespace std;class Person {
private: // 将成员变量设置为私有权限string name;int age;public:// 公共函数用于访问和设置私有属性void setName(string n) {name n;}void setAge(int a) {if (a 0)age a;elsecout Invalid age input! Age must be non-negative. endl;}void displayInfo() {cout Name: name , Age: age endl;}
};int main() {Person p1;// 不能直接访问私有属性必须通过公共函数进行操作// p1.name Alice; // 编译错误无法直接访问私有属性p1.setName(Alice);p1.setAge(25);p1.displayInfo();return 0;
} 下面给出具体代码展示如何在 C 中定义一个 Person类并设置不同类型的成员属性权限代码解释如下 注成员属性设置为私有的两点好处1、可以自己控制读写权限2、对于写可以检测数据的有效性 1类定义 a、Person类包含了三个成员属性m_Name, m_Age, 和 m_Lover b、m_Name在类中被设置为私有属性但提供了公共的 setName和 getName函数来实现对姓名的读写操作 c、m_Age也是私有属性但提供了只读的 getAge函数和可写的 setAge函数用于实现对年龄的读取和设置并限定年龄在范围 (0~150) 内 d、m_Lover是只写属性无法通过公共函数直接读取只有 setLover函数可用于设置情人的名字。 2主函数 a、在 main() 函数中实例化了一个 Person类对象 p b、由于成员属性被设置为私有在外部无法直接访问 m_Name, m_Age, 或 m_Lover属性。通过调用公共函数 setName和 getName可以完成对姓名的读写操作 c、setAge和 getAge可以完成对年龄的操作setLover可以设置情人的名字但无法直接读取。
#includeiostream
using namespace std;
#include string// 设置人的一个类
class Person
{public://设置姓名void setName(string name){m_Name name;}// 获取姓名string getName() // 这里直接返回一个string类型的字符串姓名{return m_Name;}// 获取年龄 改成可读可写年龄范围(0~150之间)int getAge(){// m_Age 0;return m_Age;}// 设置年龄void setAge(int age){if (age0||age150){m_Age 0;cout 输入错误 endl;return;}m_Age age;}// 设置情人只写不读void setLover(string name){m_Lover name;}private:// 姓名 可读可写string m_Name;// 年龄 只读int m_Age; // 情人 只写string m_Lover;};int main()
{Person p;
// p.m_Name 张三; //现在所有的成员属性都在私有中无法进行访问p.setName(张三);cout 姓名为 p.getName() endl; // 现在姓名就可以完成读写操作p.setAge(10);cout 年龄为 p.getAge() endl; //年龄是一只读的参数因此无法设置年龄p.setLover(无语); // 这里是无法显示的因为这个名字只能写入而不能读取system(pause);return 0;
}
08-封装案例1-设计立方体 接下来进行封装案例代码的编写从实战中分析封装的作用 分为三个步骤完成a、设计立方体类(Cube)b、求出立方体的面积和体积c、分别用全局函数和成员函数判断两个立方体是否相等。 下面这个示例演示了一个名为 Cube 的类该类表示立方体并提供了一些方法来设置其长、宽、高计算表面积和体积并且提供了两种方法来判断两个立方体是否相等。下面对代码进行详细解释如下 1类定义 a、Cube类包含了三个私有成员属性 m_L、m_W 和 m_H分别表示立方体的长、宽和高。 b、提供了公共的成员函数 setL, getL, setW, getW, setH, getH 来设置和获取长、宽和高。 c、提供了公共的成员函数 calculateS 和 calculateV 来计算立方体的表面积和体积。 d、提供了一个成员函数 isSameByClass 用于判断当前立方体对象和另一个立方体对象是否相等。 2全局函数 a、提供了一个全局函数 isSame接受两个立方体对象作为参数用于判断这两个立方体对象是否相等。 3主函数 a、在 main() 函数中首先创建了两个 Cube 类的对象 C1 和 C2分别表示两个立方体并设置它们的长、宽和高。 b、调用了成员函数 calculateS 和 calculateV 分别计算了 C1 的表面积和体积并将结果输出。 c、利用全局函数 isSame 判断了 C1 和 C2 是否相等并输出结果。 d、利用成员函数 isSameByClass 也判断了 C1 和 C2是否相等并输出结果。
#include iostream
using namespace std;class Cube
{
public://设置长void setL(int L){m_L L;}//获取长int getL(){return m_L;}//设置宽void setW(int W){m_W W;}//获取宽int getW(){return m_W;}//设置高void setH(int H){m_H H;}//获取高int getH(){return m_H;}//获取立方体面积int calculateS(){return 2 * (m_L*m_W m_L*m_H m_W*m_H);}// 获取立方体体积int calculateV(){return m_L*m_W*m_H;}//利用成员函数判断C1和C2是否相等bool isSameByClass(Cube C) // 这里只需要一个参数即可因为默认的已经有一个成员了再加入一个去比较{if (m_L C.getL() m_W C.getW() m_H C.getH()){return true;}return false;}private: //设置为私有的方便使用//长int m_L;//宽int m_W;//高int m_H;
};// 利用全局函数判断两个立方体是否相等可以返回bool值真和假
bool isSame(Cube C1,Cube C2)
{if (C1.getL()C2.getL()C1.getW() C2.getW()C1.getH()C2.getH()){return true;}return false;}int main()
{Cube C1; C1.setL(10);C1.setW(10);C1.setH(10);cout C1的面积为 C1.calculateS() endl;cout C1的体积为 C1.calculateV() endl;// 创建第二个立方体Cube C2;C2.setL(10);C2.setW(10);C2.setH(11);//利用全局函数判断bool ret isSame(C1, C2);if (ret){cout 全局函数判断 C1和C2相等 endl;} else{cout 全局函数判断 C1和C2不相等 endl;}// 利用成员函数判断ret C1.isSameByClass(C2);if (ret){cout 成员函数判断 C1和C2相等 endl;}else{cout 成员函数判断 C1和C2不相等 endl;}system(pause);return 0;
}
09-封装案例2-判断点和圆的关系 接下来进行封装案例代码的编写从实战中分析封装的作用 分为三个文件完成a、圆的.cpp和.h文件b、点的.cpp和.h文件c、主函数文件。 Circle.cpp文件代码如下
#include Circle.h// 设置半径
void Circle::setR(int r)
{m_R r;
}
// 获取半径
int Circle::getR()
{return m_R;
}// 设置圆心
void Circle::setCenter(Point center)
{m_Center center;}
// 获取圆心
Point Circle::getCenter()
{return m_Center;
}Circle.h文件代码如下
#pragma once // 这句代码是防止头文件重复包含使用的
#include iostream
using namespace std;
#include point.h// 设计圆的类
class Circle
{
public:// 设置半径void setR(int r);// 获取半径int getR();// 设置圆心void setCenter(Point center);// 获取圆心Point getCenter();private:// 圆的半径int m_R;// 圆的坐标中心 这里可以再建立一个关于点的类Point m_Center; // 在类中又建立了另一个类在本类中作为一个成员存在
};point.cpp文件代码如下
#include point.hvoid Point::setX(int x)
{m_X x;
}
// 获取X坐标
int Point::getX()
{return m_X;
}
// 设置Y坐标
void Point::setY(int y)
{m_Y y;
}
// 获取X坐标
int Point::getY()
{return m_Y;
} point.h文件代码如下
#pragma once
#include iostream
using namespace std;class Point
{
public://设置成员函数// 设置X坐标void setX(int x);// 获取X坐标int getX();// 设置Y坐标void setY(int y);// 获取X坐标int getY();private:// X坐标int m_X;// Y坐标int m_Y;
}; main主函数文件代码如下
#include iostream
using namespace std;
#include point.h
#include Circle.h// 判断点和圆的关系最好写成全局函数
void isInCircle(Circle c, Point p)
{// 计算两点之间的距离int distance (c.getCenter().getX() - p.getX())*(c.getCenter().getX() - p.getX()) (c.getCenter().getY() - p.getY())*(c.getCenter().getY() - p.getY());int rDistance c.getR()*c.getR();if (distance rDistance){cout 点在圆上 endl;}else if(distancerDistance){cout 点在圆外 endl;}else{cout 点在圆内 endl;}
}int main()
{Circle c1;c1.setR(10);// 创建圆心Point center;center.setX(10);center.setY(0);c1.setCenter(center);// 创建点Point p;p.setX(10);p.setY(11);isInCircle(c1, p);system(pause);return 0;
} 案例运行结果如下图所示 总结 在C中类和对象是面向对象编程的基本概念是实现封装、继承和多态的重要手段。封装是面向对象编程中的一项重要特性它将数据和操作封装在一个单元类中隐藏了内部的细节只向外部提供必要的接口来访问和操作数据。封装通过访问控制public、private、protected来实现数据的保护和安全性同时实现数据隐私性和信息隐藏。 封装是面向对象编程的重要特性它通过将数据和行为整合在一起实现了数据的隐藏和保护是实现面向对象编程的核心概念之一。
