网站新闻标题字数,东莞常平常安医院,龙岗模板网站建设,宁夏住房和城乡建设厅网站首页目录
一、对象数组
二、对象指针
三、this 指针
四、类类型作为参数类型的三种形式
4.1 对象本身作为参数
4.2 对象指针作为参数
4.3 对象引用作为参数
五、静态成员
5.1 静态数据成员
5.2 静态成员函数
六、友元机制
6.1 友元函数
6.2 友元类
七、类的组合
八、…目录
一、对象数组
二、对象指针
三、this 指针
四、类类型作为参数类型的三种形式
4.1 对象本身作为参数
4.2 对象指针作为参数
4.3 对象引用作为参数
五、静态成员
5.1 静态数据成员
5.2 静态成员函数
六、友元机制
6.1 友元函数
6.2 友元类
七、类的组合
八、数据成员的初始化和释放顺序
九、常对象与常成员
9.1 常对象
9.2 常成员
9.2.1 常成员函数
9.2.2 常成员数据 一、对象数组
在C中可以使用对象数组来存储和操作一组相关的对象。下面是一个示例
class Student {
private:std::string name;int age;std::string gender;public:// 构造函数Student(std::string n, int a, std::string g) {name n;age a;gender g;}// Getter 和 Setter 方法std::string getName() {return name;}void setName(std::string n) {name n;}int getAge() {return age;}void setAge(int a) {age a;}std::string getGender() {return gender;}void setGender(std::string g) {gender g;}
};int main() {// 声明一个存储 Student 对象的数组Student students[10];// 初始化数组中的每个对象students[0] Student(张三, 18, 男);students[1] Student(李四, 19, 女);// ...// 访问对象数组中的元素std::cout 第一个学生的姓名是 students[0].getName() std::endl;std::cout 第二个学生的年龄是 students[1].getAge() std::endl;// 修改对象数组中的元素students[0].setName(王五);students[1].setAge(20);return 0;
}在上面的示例中Student 是一个自定义的类有姓名、年龄和性别等属性。然后在main函数中声明了一个名为students的对象数组用来存储多个学生对象。可以通过索引访问和操作每个学生对象。最后通过对象数组可以方便地对一组学生对象进行管理和操作。 二、对象指针
对象指针是指指向对象的指针变量。在C中可以通过使用对象指针来操作对象的成员和调用成员函数。
通过对象指针可以访问对象的成员使用 -运算符可以在指针上调用成员函数和访问成员变量。例如studentPtr-getName()会调用Student对象的getName()函数。
下面是一个示例
class Student {
private:std::string name;int age;std::string gender;public:// 构造函数Student(std::string n, int a, std::string g) {name n;age a;gender g;}// Getter 和 Setter 方法std::string getName() {return name;}void setName(std::string n) {name n;}int getAge() {return age;}void setAge(int a) {age a;}std::string getGender() {return gender;}void setGender(std::string g) {gender g;}
};int main() {// 声明一个指向 Student 对象的指针Student* studentPtr;// 创建一个 Student 对象并将指针指向该对象Student student(张三, 18, 男);studentPtr student;// 通过指针访问对象的成员std::cout 学生的姓名是 studentPtr-getName() std::endl;std::cout 学生的年龄是 studentPtr-getAge() std::endl;// 通过指针调用对象的成员函数studentPtr-setName(王五);studentPtr-setAge(20);return 0;
}在上面的示例中Student是一个自定义的类有姓名、年龄和性别等属性。然后在main函数中声明了一个名为studentPtr的指针变量用来指向Student对象。通过使用 操作符我们将指针studentPtr指向了一个实际的Student对象 student。
注意
当使用对象指针时必须确保指针指向的对象是有效的未被销毁。否则在使用指针访问成员时可能会导致程序崩溃或未定义行为。 三、this 指针
this指针是一个指向当前对象的指针它可以在类的成员函数中使用。在C中每个非静态成员函数都有一个隐含的this指针它指向调用该函数的对象。通过this指针可以在成员函数中访问和操作对象的成员变量和成员函数。
下面是一个示例
class MyClass {
private:int value;public:// 构造函数MyClass(int v) {value v;}// 成员函数void printValue() {std::cout 对象的值是 value std::endl;}void setValue(int v) {this-value v;}void printAddress() {std::cout 对象的地址是 this std::endl;}
};int main() {MyClass obj(10);obj.printValue();obj.setValue(20);obj.printValue();obj.printAddress();return 0;
}在上面的示例中MyClass是一个包含一个私有成员变量value和一些成员函数的类。在printValue函数中我们使用this指针来访问对象的成员变量value并打印出来。在setValue函数中我们使用this指针来设置对象的成员变量value的值。
this指针还可以用于获取对象的地址如printAddress函数所示。通过打印this指针我们可以看到它指向的是创建的对象的地址。
注意
this指针是一个常量指针不能被修改和赋值。所以不能将this指针作为参数传递给其他函数或赋值给其他指针变量。它只能被用于访问当前对象的成员。 四、类类型作为参数类型的三种形式
4.1 对象本身作为参数
在C中可以将一个类类型的对象本身作为参数传递给函数。这意味着函数可以直接操作和修改对象的成员变量和成员函数。
示例如下
#include iostreamclass MyClass {
public:int x;MyClass(int a) {x a;}void func() {std::cout x的值为: x std::endl;}
};void modifyObject(MyClass obj) {obj.x 10;
}int main() {MyClass obj(5);obj.func(); // 输出: x的值为: 5modifyObject(obj);obj.func(); // 输出: x的值为: 5对象本身不会被修改return 0;
}在上面的示例中我们定义了一个名为MyClass的类它包含一个整型成员变量x 和一个成员函数func()。然后我们定义了一个函数modifyObject()它接受一个MyClass对象作为参数。在modifyObject()函数中我们试图修改传递进来的对象的 x成员变量的值但实际上这个修改只在modifyObject()函数内部生效并不会影响到调用函数时传递的原始对象。所以在主函数main()中我们调用modifyObject(obj)后再次输出obj.x的值时它的值仍然是调用前的原始值。
注意
当将一个对象作为参数传递给函数时C会调用对象的拷贝构造函数来创建一个新的对象。这意味着函数内部对该对象的修改不会影响到原始对象。如果希望在函数内部修改原始对象的值可以将对象作为引用或指针来传递。 4.2 对象指针作为参数
在C中我们可以将对象指针作为函数的参数来传递对象。使用对象指针作为参数可以使函数对对象进行原地修改而不必复制对象或返回新对象。
下面是一个简单的示例展示了如何将对象指针作为参数传递
#include iostreamclass MyClass {
public:int num;void printNum() {std::cout The number is: num std::endl;}
};// 接受对象指针作为参数的函数
void updateNum(MyClass* obj, int newNum) {obj-num newNum;
}int main() {MyClass obj;obj.num 10;obj.printNum(); // 输出: The number is: 10updateNum(obj, 20);obj.printNum(); // 输出: The number is: 20return 0;
}在上面的示例中我们定义了一个MyClass类它包含一个整数成员变量num 和一个打印成员变量的函数printNum()。我们还定义了一个名为updateNum()的函数它接受一个MyClass对象指针和一个新的整数值并将对象的num变量更新为新值。
在main()函数中我们创建一个MyClass对象obj并将其变量设置为10。我们调用updateNum()函数将obj的指针和新值20作为参数传递。这样updateNum()函数就可以直接操作obj的num变量并将其值更新为20。最后我们再次调用printNum()函数来验证num变量是否已经更新为20。
注意
在使用对象指针时要确保对象是有效的并在不再需要时及时释放内存。 4.3 对象引用作为参数
在C中我们可以将对象引用作为函数的参数来传递对象。使用对象引用作为参数可以使函数对对象进行原地修改而不必复制对象或返回新对象。与对象指针相比不需要使用额外的操作符来访问成员变量。同时对象引用也自动处理了对象是否为有效的情况因此不需要在使用之前进行额外的检查。
下面是一个简单的示例展示了如何将对象引用作为参数传递
#include iostreamclass MyClass {
public:int num;void printNum() {std::cout The number is: num std::endl;}
};// 接受对象引用作为参数的函数
void updateNum(MyClass obj, int newNum) {obj.num newNum;
}int main() {MyClass obj;obj.num 10;obj.printNum(); // 输出: The number is: 10updateNum(obj, 20);obj.printNum(); // 输出: The number is: 20return 0;
}在上面的示例中我们定义了一个MyClass类它包含一个整数成员变量num和一个打印成员变量的函数printNum()。我们还定义了一个名为updateNum()的函数它接受一个MyClass对象引用和一个新的整数值并将对象的num变量更新为新值。
在main()函数中我们创建一个MyClass对象obj并将其num变量设置为10。然后我们调用updateNum()函数将obj和新值20作为参数传递。这样updateNum()函数就可以直接操作obj的num变量并将其值更新为20。最后我们再次调用printNum()函数来验证num变量是否已经更新为20。
注意
一旦对象引用作为参数传递给函数函数内部对对象的修改将会影响到原始对象。因此在使用对象引用作为函数参数时要格外小心确保不会意外修改对象的状态。 五、静态成员
静态成员是类的成员而不是对象的成员。它们与类相关联而不是与特定的对象相关联。静态成员在类的所有对象之间共享并且可以通过类名来访问而不需要创建类的实例。
静态成员可以是静态数据成员或静态成员函数。静态数据成员在类中只有一个实例并且可以在所有对象之间共享。静态成员函数不依赖于任何特定对象的实例可以直接通过类名来调用。 5.1 静态数据成员
在C中静态数据成员是类的特殊成员它被该类的所有对象所共享而不是每个对象独立拥有。静态数据成员的值在类的所有对象中是相同的。
静态数据成员具有以下特点
静态数据成员属于整个类而不是类的某个具体对象。它在内存中只有一份拷贝而不是每个对象都有一份。静态数据成员可以在类的内部声明在类的外部进行定义和初始化。在定义时需要在成员名称前加上static关键字同时需要在类的外部进行变量的定义和初始化。静态数据成员的作用域限定在所属的类内部可以通过类名和作用域解析操作符::来直接访问。静态数据成员可以在类的对象之间共享数据可以用于在对象之间传递共享的数据。
以下是一个示例
class MyClass {
public:static int myStaticVar; // 静态数据成员的声明static int getStaticVar() { // 静态成员函数可以直接访问静态数据成员return myStaticVar;}
};int MyClass::myStaticVar 0; // 静态数据成员的定义和初始化int main() {MyClass obj1;MyClass obj2;obj1.myStaticVar 5;cout obj1.myStaticVar endl; // 输出 5cout obj2.myStaticVar endl; // 输出 5静态数据成员在所有对象中共享cout MyClass::myStaticVar endl; // 通过类名访问静态数据成员return 0;
}在以上示例中myStaticVar是一个静态成员变量通过类名来访问。通过对象obj1和obj2来访问myStaticVar它们都共享相同的值。静态成员函数getStaticVar()可以直接访问静态数据成员。 5.2 静态成员函数
在C中静态成员函数是属于整个类的而不是类的某个对象它不依赖于特定的对象实例。静态成员函数可以直接通过类名来调用而不需要创建对象。
静态成员函数具有以下特点
静态成员函数没有this指针因此不能直接访问非静态成员变量和非静态成员函数。它只能访问静态成员变量和静态成员函数。静态成员函数可以在类的内部声明在类的外部进行定义。静态成员函数的调用方式是通过类名和作用域解析操作符::来调用。
以下是一个示例
class MyClass {
public:static int myStaticVar; // 静态数据成员的声明static int getStaticVar() { // 静态成员函数的定义return myStaticVar;}static void setStaticVar(int value) {myStaticVar value;}
};int MyClass::myStaticVar 0; // 静态数据成员的定义和初始化int main() {MyClass::setStaticVar(5); // 通过类名调用静态成员函数cout MyClass::getStaticVar() endl; // 通过类名调用静态成员函数return 0;
}在以上示例中getStaticVar()和setStaticVar()都是静态成员函数可以直接通过类名来调用。静态成员函数可以用于访问和操作静态数据成员而不依赖于具体的对象实例。 六、友元机制
友元机制是C中一种特殊的访问权限控制机制它允许一个类或函数访问另一个类的私有成员。
在C中可以使用friend关键字将一个函数或类声明为友元。被声明为友元的函数或类可以直接访问其它类的私有和保护成员而不受访问权限的限制。 6.1 友元函数
友元函数是指被声明为某个类的友元的函数可以访问该类的私有成员和保护成员。通过友元函数可以实现一些与该类有关的操作即使这些操作不属于该类的成员函数。
以下是一个友元函数的示例
class MyClass {
private:int privateData;public:MyClass(int data) : privateData(data) {}friend int friendFunction(MyClass obj);
};int friendFunction(MyClass obj) {// 友元函数可以访问私有成员return obj.privateData;
}int main() {MyClass myObj(5);int data friendFunction(myObj);cout Private data: data endl;return 0;
}在上述示例中MyClass类声明了一个友元函数friendFunction()并将其声明为友元。friendFunction()函数可以访问MyClass的私有成员privateData。
在main()函数中我们创建了一个MyClass对象myObj并将其初始化为5。然后调用friendFunction()函数该函数访问了myObj的私有成员privateData并返回它。最后我们将返回的私有数据打印到控制台上。
通过友元函数我们可以方便地访问类的私有成员但同样需要谨慎使用以保护数据的封装性。 6.2 友元类
友元类是指一个类被声明为另一个类的友元可以访问该类的私有成员和保护成员。这样友元类可以在其成员函数中访问被友元类的私有成员。
以下是一个友元类的示例
class FriendClass {
private:int privateData;public:FriendClass(int data) : privateData(data) {}friend class MyClass;
};class MyClass {
public:void accessPrivateData(FriendClass obj) {// 友元类可以访问私有成员int data obj.privateData;cout Private data: data endl;}
};int main() {FriendClass friendObj(5);MyClass myObj;myObj.accessPrivateData(friendObj);return 0;
}在上述示例中FriendClass类被声明为MyClass类的友元类。因此在MyClass类中的成员函数accessPrivateData()中可以访问FriendClass类的私有成员privateData。
在main()函数中我们创建了一个FriendClass对象friendObj并将其初始化为5。然后我们创建了一个MyClass对象myObj并调用其成员函数accessPrivateData()将friendObj作为参数传递给它。accessPrivateData()函数可以访问friendObj的私有成员privateData并将其打印到控制台上。
通过友元类类之间的访问限制可以得到打破但同样需要谨慎使用以保护数据的封装性。 七、类的组合
在C中类的组合是指一个类包含另一个类的对象作为其成员。通过组合一个类可以使用另一个类的功能并将其封装在自己的实现中。
组合是一种常用的实现方式它允许类之间建立关联关系并共享彼此的功能。通过组合我们可以构建更加复杂和灵活的类结构。
下面是一个示例展示了如何在C中使用类的组合
// 定义一个矩形类
class Rectangle {
private:int width;int height;public:Rectangle(int w, int h) {width w;height h;}int calculateArea() {return width * height;}
};// 定义一个房间类使用矩形类的对象作为成员
class Room {
private:Rectangle area;int numOfWindows;public:Room(int w, int h, int windows) : area(w, h) {numOfWindows windows;}int calculateTotalArea() {return area.calculateArea() * numOfWindows;}
};int main() {// 创建一个房间对象Room myRoom(10, 12, 4);// 计算房间的总面积int totalArea myRoom.calculateTotalArea();// 输出结果cout Total area of the room: totalArea endl;return 0;
}在上面的示例中Rectangle类表示一个矩形它有一个calculateArea方法来计算矩形的面积。Room类表示一个房间它有一个calculateTotalArea方法来计算房间的总面积通过将Rectangle类的对象作为成员变量area来实现矩形的组合。通过创建一个Room对象我们可以调用其方法来计算房间的总面积。 八、数据成员的初始化和释放顺序
在C中类的数据成员的初始化和释放顺序是按照它们在类中的声明顺序确定的。初始化顺序是在进入构造函数的初始化列表之前确定的而释放顺序是在析构函数中完成的通过使用初始化列表在构造函数中可以确保数据成员正确初始化。而在析构函数中数据成员的释放顺序与初始化顺序相反。
下面是一个示例展示了数据成员初始化和释放顺序的规则
class MyClass {
private:int x;int y;int z;public:MyClass(int a, int b, int c) : x(a), y(b), z(c) {// 构造函数}~MyClass() {// 析构函数}
};在上面的示例中MyClass类有三个整型数据成员x、y和z。在构造函数中我们使用初始化列表来初始化这些成员变量按照它们在类中的声明顺序先初始化x然后是y最后是z。在析构函数中成员变量的释放顺序与初始化顺序相反先释放z然后是y最后是x。
注意
如果一个数据成员是一个对象或者指向一个对象的指针在构造函数中如果需要使用它那么它必须在初始化列表中进行初始化。 九、常对象与常成员
9.1 常对象
常对象是指被声明为const的对象即对象的值在创建后就不能被修改。
常对象的定义方法
在对象声明时直接加上const关键字。
const ClassName obj; // 声明一个常对象使用类型别名或引用来声明常对象。
typedef const ClassName CObj; // 声明一个常对象的类型别名CObj
CObj obj; // 声明一个常对象常对象的特点如下
常对象的状态是只读的无法通过任何途径修改其成员变量的值。常对象只能调用其类中被声明为const的成员函数不能调用非const成员函数。常对象可以调用常成员函数因为常成员函数不会修改任何成员变量的值。
常对象在实际编程中有很多用途例如
在函数中传递常对象作为参数以防止函数修改对象的值。在类的成员函数中常对象可以被用作参数或返回值以保证函数的纯粹性。常对象可以用于实现单例模式中的只读实例。
通过使用常对象可以提高程序的安全性和可维护性避免对象值的意外修改。 9.2 常成员
9.2.1 常成员函数
常成员函数指的是在类中声明的成员函数加上const关键字表示该函数不会修改对象的状态。常成员函数可以被常对象调用确保对象在调用该函数时不会被修改。
常成员函数的定义方式
class ClassName {
public:void functionName() const;
};在函数声明后加上const关键字表示该函数是一个常成员函数。常成员函数可以在类的内部或外部进行定义。
常成员函数的特点如下
常成员函数不能修改对象的非常量数据成员。它只能读取数据成员的值而不能修改它们。常成员函数只能调用其他常成员函数而不能调用非常成员函数。这是为了保证在常成员函数中不会修改对象的状态。 9.2.2 常成员数据
常成员数据指的是在类中声明的成员变量加上const关键字表示该变量的值在对象创建后就不能被修改。常成员数据必须在类的构造函数初始化列表中进行初始化。
常成员数据的定义方式为
class ClassName {
private:const int variableName;
public:ClassName(int value) : variableName(value) {}
};在成员变量的类型前加上const关键字表示该变量是一个常成员数据。在构造函数初始化列表中对常成员数据进行初始化。
常成员数据的特点如下
常成员数据的值在对象创建后就不能被修改它们被视为对象的常量。常成员数据只能在构造函数的初始化列表中进行初始化而不能在构造函数内部或其他成员函数中进行修改。
