一,对象的动态建立和释放
1.什么是对象的动态建立和释放
通常我们创建的对象都是由C++编译器为我们在栈内存中创建的,我们无法对其进行生命周期的管理。所以我们需要动态的去建立该对象,因此我们需要在堆内存中创建对象和释放对象。在C语言中为我们提供了malloc()函数和free()函数来为我们提供在堆内存中分配变量的方式,但是在C++中引入了new和delete关键字来让我们动态的创建和释放变量。
2.new和delete关键字
- new关键字是用来在堆内存中创建变量的,格式为:Type * ptr = new Type(常量/表达式); 其参数列表中的常量/表达式可以用来给变量初始化,也可以省略不写。其返回结果为该类型的指针。如果内存分配失败则返回空指针。
- delete关键字是用来释放用new关键字创建的内存,格式为delete ptr(释放数组必须需要加中括号,delete [] ptr)。
3.new和delete关键字与malloc和free的区别
- new关键字在分配内存的时候,会根据其创建的参数调用相应的类的构造函数。delete关键字会在释放内存之前,会首先调用类的析构函数释放对象中定义的内存。
- malloc和free关键字不会去调用类的构造函数和析构函数。
4.new和delete关键字示例
# define _CRT_SECURE_NO_WARNINGS # include<iostream> using namespace std; class Teacher { public: char * name; int age; public: /* 无参构造函数 */ Teacher() { name = NULL; age = 0; cout << "无参构造函数被执行..." << endl; } /* 有参构造函数 */ Teacher(char * name, int age) { /* 在构造函数中分配堆内存 */ this->name = new char[sizeof(name) + 1]; /* 初始化成员变量 */ strcpy(this->name, name); this->age = age; cout << "有参构造函数被执行..." << endl; } /* 拷贝构造函数 */ Teacher(const Teacher &student) { /* 重新分配内存 */ this->name = new char[sizeof(name) + 1]; /* 初始化成员变量 */ strcpy(this->name, name); this->age = age; cout << "拷贝构造函数被执行..." << endl; } /* 析构函数 */ ~Teacher() { if (this->name != NULL) { delete [] this->name; this->name = NULL; this->age = 0; } cout << "析构函数被执行..." << endl; } }; int main() { /* 创建int变量,并释放 */ int * a = new int; int * b = new int(100); delete a; delete b; /* 创建double变量,并释放 */ double * c = new double; double * d = new double(10.1); delete c; delete d; /* 创建数组并释放 */ char * e = new char[100]; delete [] e; /* 创建对象并释放 */ Teacher * stu1 = new Teacher("王刚",22); cout << "姓名:" << stu1->name << ",年龄:" << stu1->age << endl; Teacher * stu2 = new Teacher(); delete stu1; delete stu2; /* 利用malloc和free创建对象,无法调用其构造和析构函数*/ Teacher * stu3 = (Teacher *)malloc(sizeof(Teacher)); free(stu3); }
二,静态成员变量和静态成员函数
1.static关键字
static关键字用来声明类中的成员为静态属性。当用static关键字修饰成员后,该类所创建的对象共享static成员。无论创建了多少个对象,该成员只有一份实例。静态成员是与类相关的,是类的一种行为,而不是与该类的对象相关。
2.静态成员的概念
静态成员是类所有的对象的共享成员,而不是某个对象的成员,它在对象中不占用存储空间,这个成员属于整个类,而不属于具体的一个对象,所以静态成员变量无法在类的内部进行初始化,必须在类的外部进行初始化。比如定义一个学生类,那么学生对象总数可以声明为static,在构造方法中,对该变量进行加1,从而统计学生对象的数量。
3.静态成员变量总结
- 静态成员变量可以用static关键字定义,但是初始化必须在类的外面进行初始化。
- 静态成员变量可以被类及类的对象所访问和修改。
- 静态成员变量遵循类的访问控制原则,如果为private修饰,则只可以在类的内部和在类外面初始化的时候访问,不会再被其他方式访问。
4.静态成员函数总结
- 静态成员函数用static关键字定义,在静态成员函数中可以访问静态成员变量和静态成员函数,但不允许访问普通的成员变量和成员函数,因为普通的成员属于对象而不属于类。层次不一样。但是在普通成员中可以访问静态成员。
- 当静态成员函数在类中定义,但是在类的外面实现的时候,不需要再加static关键字。
- 静态成员函数没有this指针。
5.静态成员重点归纳
- 静态成员是类和类的对象的所有者,因此静态成员变量不能在类的内部进行初始化,必须在类的外部进行初始化。
- 静态成员依旧遵循private,protected,public的访问控制原则。
- 静态成员函数中没有this指针,不能访问普通的成员变量和成员函数,可以访问静态成员变量和成员函数,但是可以通过传递对象的方式访问普通成员。
6.静态成员变量演示
# include<iostream> using namespace std; class MyStudent { private: static int count;/* 学生对象总数 */ char name[64]; int age; public: static int n; public: MyStudent(char * name,int age) { strcpy(this->name, name); this->age = age; MyStudent::count++;/* 学生数量加1 */ } void getCount()/* 普通成员函数访问静态成员变量 */ { cout << "学生总数:" << MyStudent::count << endl; } }; /* 静态成员变量初始化 */ int MyStudent::count = 0; int MyStudent::n = 10; int main() { /* 测试静态成员变量 */ MyStudent student1("王刚",22); student1.getCount(); /* 对象和类方式访问静态成员变量 */ student1.n = 100; MyStudent::n = 200; }
7.静态成员函数演示
# include<iostream> using namespace std; class Test { private: int m; public: static int n; public: void setM(int m) { this->m = m; /* 访问静态成员函数 */ test(); } public: static void xoxo(); static void test() { n = 100; // m = 10; 不允许访问普通成员变量 // int c = getM(); 不允许访问普通成员函数 // this->m = 1000; this指针不存在 cout << "static void test()函数..." << endl; } }; /* 初始化静态成员 */ int Test::n = 10; /* 类中声明,类外实现 */ void Test::xoxo() { cout << "static void Test::xoxo" << endl; } int main() { Test t; /* 普通成员函数访问静态成员函数 */ t.setM(10); /* 成员函数的调用方式 */ t.test(); Test::test(); }
三,友元函数和友元类
1.友元函数
当我们定义类的时候,使用private关键字修饰成员变量(成员函数),这样做到了访问控制。有些时候,我们需要让一些函数来访问对象的私有成员(属性或方法),C++为我们提供了友元函数这个概念,所谓的友元函数就是指这个函数是这个类的好朋友,允许让这个函数访问这个类创建的对象的私有属性和私有方法。友元函数用friend函数来声明,友元函数的声明必须在类的内部,友元函数的实现必须要在类的外部(如果友元函数的实现也在内部,那还要用友元函数干什么?),友元函数的声明位置与访问控制符无关。
2.友元函数示例
# include<iostream> using namespace std; /* 定义点类 */ class Point { private: int x; int y; /* 友元函数的定义:求两点的距离 */ friend int distance(Point &p1, Point &p2); public: Point(int x, int y) { this->x = x; this->y = y; } }; /* 友元函数的实现 */ int distance(Point &p1, Point &p2) { int dx = p1.x - p2.x; int dy = p1.y - p2.y; return sqrt(dx*dx + dy*dy); } int main() { Point p1(3, 4); Point p2(0, 0); int dis = distance(p1, p2); cout << "点(3,4)到原点的距离为:" << dis << endl; }
3.友元类
- 若B类是A类的友元类,则B类的所有成员函数都是A类的友元函数。类B可以访问类A的所有私有属性和方法。
- 友元类通常被设计为一种对数据操作或者类之间传递消息的辅助类。
4.友元类示例
# include<iostream> using namespace std; /* 定义类A */ class A { private: int x; friend class B;/* 定义类B为类A的友元类 */ private: void setX(int x) { this->x = x; } }; /* 定义类B */ class B { private: A AObj; public: /* 类B的所有成员函数都是类A的友元函数,因此都可以访问类A的私有属性和方法 */ void operater(int tmp) { AObj.setX(tmp); } void display() { cout << "类A的私有属性x = " << AObj.x << endl; } }; int main() { B b; b.operater(100); b.display(); return 0; }