本篇要学习的内容和知识结构概览
类及其实例化
类的定义
将一组对象的共同特征抽象出来, 从而形成类的概念.
类包括数据成员和成员函数, 不能在类的声明中对数据成员进行初始化
声明类
形式为：
class 类名 { private: 私有数据和函数 public: 公有数据和函数 protected: 受保护的数据和函数 }; // 注意分号
无论是数据成员还是成员函数, 都是这个类的成员, 都具有一个访问权限, 如果没有关键字进行修饰, 则默认为private权限
声明一个类, 像这样：
// 声明类 class Point { // 如果没有修饰符, 默认为私有的权限 double x; double y; public: // 无参构造函数 Point(); // 有参构造函数 Point(double a, double b); // 成员函数 void display(); };
定义成员函数
形式为：
// :: 为作用域运算符, 表示这个函数属于哪个类
返回类型 类名::成员函数名(参数列表) {
函数体 // 内部实现
}
我们在上面的声明类的代码中, 声明了成员函数, 我们可以在类外面定义成员函数, 也就是给出函数体
像这样：
// 定义成员函数 // 无参构造函数 Point::Point() {} // 有参构造函数 Point::Point(double a, double b) { x = a; y = b; } // 可以使用关键字inline将成员函数定义为内联函数 inline void Point::display() { cout << x << ", " << y << endl; }
如果在声明类的同时, 在类体内给出成员函数的定义, 则默认为内联函数
我们一般都是在类体内存给出成员函数的定义
像这样, 完成一个类的声明和定义
// 声明类 class Point { double x; double y; public: // 定义成员函数 Point() {} Point(double a, double b) { x = a; y = b; } void display() { // 默认为内联函数 cout << x << ", " << y << endl; } };
不能在类体内和类体外对数据数据成员赋值
像这样是不行的：
class Point { // 在类体内不能给数据成员赋值 double x = 2; double y = 3; } // 在类体外不能给数据成员赋值 // x = 4; // y = 5;
只有产生了具体对象, 这些数据值才有意义
初始化: 在产生对象时就使对象的数据成员具有指定值, 则称为对象的初始化
赋值: 有了对象之后, 对象调用自己的成员函数实现赋值操作
使用类的对象
类的成员函数可以直接使用自己类的私有成员
类外面的函数不能直接访问类的私有成员, 而只能通过类的对象使用公有成员函数
定义类对象指针的语法: 类名 * 对象指针名 = 对象地址;
通过对象指针可以访问对象的成员: 对象指针名 -> 对象成员名;
像这样：
// 定义一个类 class Point { // 声明数据成员 double x; double y; public: // 声明并且定义成员函数 void setXY(double a, double b) { x = a; y = b; } // 一个类的成员函数可以访问自己的私有成员 void display() { cout << x << ", " << y << endl; } }; int main() { // 定义对象a Point a; // 定义b为对象a的引用 Point & b = a; // 定义p为指向对象a的指针 Point *p = &a; // 对象和引用, 都使用"."访问对象的成员 a.setXY(2, 3); b.setXY(4, 5); // 指针使用"->"访问对象的成员 p -> setXY(6, 7); }
构造函数
默认构造函数
一个类如果没有定义任何构造函数, 编译器会自动定义一个不带参数的构造函数, 也就是默认构造函数
比如我们有一个类Point
则默认构造函数就是这样：Point::Point() {};
如果一个类提供了构造函数, 系统不再提供默认构造函数
我们有一个Point类, 像这样：
class Point { double x; double y; public: Point(double a, double b) { x = a; y = b; } };
则我们就不能在main函数中这样使用：
int main() { // Point类有自己定义的构造函数Point(double, double), 所以就没有默认构造函数Point() // 这句话调用的是无参构造函数来定义一个对象, 所以编译错误 // 我们需要给类Point加上无参构造函数 Point a; }
我们想要这样使用, 则必须手动添加无参数构造函数
像这样：
class Point { double x; double y; public: // 无参构造函数 Point(){} // 有参构造函数 Point(double a, double b) { x = a; y = b; } ; int main() { // 我们给类加上自定义无参构造函数, 现在正确编译 Point a; }
定义构造函数
构造函数的名字应该与类名同名, 并在定义构造函数时不能指定返回类型, void也不可以
// 声明一个类 class Point { double x; double y; public: // 声明无参构造函数 Point(); // 声明有参构造函数 Point(double, double); }; // 在类外定义构造函数 Point::Point(){} // 第一种定义构造函数 //Point::Point(double a, double b):x(a),y(b){} // 第二种定义构造函数 Point::Point(double a, double b) { x = a; y = b; } int main() { // 产生对象 Point a(2, 3); }
我们一般都在类的声明内部进行函数定义
像这样：
// 定义一个类 class Point { // 声明数据成员 double x; double y; public: // 无参构造函数 Point(){}; // 有参构造函数 Point(double a, double b) { x = a; y = b; } }; int main() { // 无参构造函数 产生对象a Point a; // 有参构造函数 产生对象b Point b(2, 3); // 无参构造函数 产生对象数组arr1 Point arr1[2]; // 有参构造函数 产生对象数组arr2 Point arr2[2] = {Point(2, 3), Point(4, 5)}; }
注意
不能在程序中显式地调用构造函数, 构造函数是自动调用的
即不能这样: Point a.Point(2, 3);
只能这样: Point a(2, 3);
作用
用来在产生对象的同时, 进行对象的初始化
构造函数和运算符new
new用来建立生存期可控的动态对象, 返回这个对象的指针
new和构造函数一同起作用
过程: 当用new建立动态对象时, 首先分配可以保存这个类对象的内存空间, 然后自动调用构造函数来初始化这块内存, 再返回这个动态对象的地址
使用new建立的动态对象只能使用delete删除, 以释放所占空间
像这样：
// new与无参构造函数 Point * p1 = new Point; // new与有参构造函数 Point * p2 = new Point(2, 3);
构造函数的默认参数
如果我们定义了有参构造函数, 又想使用无参构造函数, 我们可以将有参构造函数的参数全部使用默认参数
像这样：
class Point { double x; double y; public: // 声明构造函数 // 有参构造函数 Point(double a = 0, double b = 0) { x = a; y = b; } // 成员函数 void display() { cout << x << ", " << y << endl; } }; int main() { // 产生对象 Point a; a.display(); }
复制构造函数
作用: 通过拷贝方式使用一个类的已有对象来建立一个该类的新对象, 一般编译器会建立一个默认的复制构造函数
像这样：类名(const 类名 &); // 为了不改变原有对象, 使用const来进行修饰
复制构造函数也可以自定义, 则编译器不再调用默认的复制构造函数
像这样：
// 定义一个类 class Point { // 声明数据成员 double x; double y; public: // 无参构造函数 Point(){ cout << "默认构造函数" << endl; }; // 有参构造函数 Point(double a, double b) { x = a; y = b; cout << "构造函数 " << x << ", " << y << endl; } // 复制构造函数 Point(const Point & t) { x = t.x; y = t.y; cout << "复制构造函数" << endl; } }; int main() { // 使用默认构造函数产生一个对象 Point a; // 使用复制构造函数产生一个对象 Point b(a); }
使用复制构造函数的三种情况
当用一个类的对象去初始化另一个对象时, 需要调用复制构造函数
像这样：
// 通过构造函数实例化对象 Point a(2, 3); // 通过构造函数实例化对象 Point b(a); // 调用成员函数 b.display();
如果函数的形参是类的对象, 调用函数时, 进行形参与实参的结合时, 需要调用复制构造函数
像这样：
// 函数, 用来显示一个Point对象 void printPoint(Point t) { // 当函数调用时形参t是通过复制构造函数来产生的对象 t.display(); } // 函数执行完毕后, 调用形参t的析构函数, 释放内存 int main() { // 产生对象a Point a(2, 3); // 调用函数 printPoint(a); } // 函数执行完毕后, 调用对象a的析构函数, 释放内存
如果函数的返回值是对象, 当函数调用完成返回时, 需要调用复制构造函数, 产生临时对象, 并在执行完返回值语句后, 析构临时对象
// 函数, 得到一个Point对象 Point getPoint() { Point * t = new Point(2, 3); return *t; // 产生一个对象 } // 函数执行完毕后, 调用对象t的析构函数, 释放内存 int main() { // 调用函数返回一个类对象, 这里在接收函数返回的对象时会自动调用复制构造函数(不调用的是编译器进行了优化) Point a = getPoint(); } // 函数执行完毕后, 调用对象a的析构函数, 释放内存
函数参数使用对象的引用不产生副本, 所以当对象作为函数参数时, 推荐使用对象引用这种方式
析构函数
作用：在对象消失时, 使用析构函数释放由构造函数分配的内存
定义析构函数
为了与构造函数区分, 在析构函数前加”~”号,
并且在定义析构函数时, 不能指定返回类型, 即使是void类型也不可以;
也不能指定参数, 但可以显式的说明参数为void
格式: ~类名(); // 或者 ~类名(void);
代码像这样:
~Point(); // 或者 ~Point(void);
析构函数在对象的生存期结束时自动调用, 然后对象占用的内存被回收
全局对象和静态对象的析构函数在程序运行结束之前调用
类对象的数组每个元素调用一次析构函数
像这样: 可以运行该代码, 查看程序执行过程
// 定义一个类 class Point { // 声明数据成员 double x; double y; public: // 无参构造函数 Point(){ cout << "默认构造函数" << endl; }; // 有参构造函数 Point(double a, double b) { x = a; y = b; cout << "构造函数 " << x << ", " << y << endl; } // 复制构造函数 Point(const Point & t) { x = t.x; y = t.y; cout << "复制构造函数" << endl; } // 析构函数 ~ Point() { cout << "析构函数" << endl; } }; int main() { // 使用默认构造函数产生一个对象 Point a; // 调用默认构造函数, 产生新对象 // 使用复制构造函数产生一个对象 Point b(a); // 调用复制构造函数, 产生新对象 // 对象数组 Point arr[2]; // 调用默认构造函数 2次, 产生两个新对象 } // 程序结束后, 因为总共产生了4个对象, 所以也会调用4次析构函数
析构函数和运算符delete
当使用运算符delete删除一个动态对象时, 首先为这个对象调用析构函数, 然后再释放这个动态对象占用的内存
像这样：
// 使用new和默认构造函数产生一个对象 Point * p = new Point; // 使用delete来释放内存 delete p; // 使用new和默认构造函数产生一个对象数组, 数组有两个对象 Point * p2 = new Point[2]; // 使用delete释放数组内存 delete []p2;
默认析构函数
如果没有定义析构函数, 编译器自动为类产生一个函数体为空的默认析构函数
像这样：~ Point(){};
成员函数重载及默认参数
成员函数可重载或使用默认参数, 为了提高可读性
// 定义一个类 class MyMax { // 私有成员 int a, b, c, d; // 函数: 求两个数的最大值 int getMax(int v1, int v2) { return v1 > v2 ? v1 : v2; } // 公有成员 public: // 函数: 改变数据成员的值 void setValue(int v1, int v2, int v3 = 0, int v4 = 0) { a = v1; b = v2; c = v3; d = v4; } // 函数: 获得所有数据成员里的最大值 (函数重载) int getMax() { return getMax(getMax(a, b), getMax(c, d)); } }; int main() { // 产生对象 MyMax a; // 改变数据成员的值 a.setValue(1, 2, 3, 4); // 调用成员函数 cout << a.getMax() << endl; }
this指针
this指针的概念和作用
当一个成员函数被调用时, 系统自动向该函数传递一个隐含的参数, 指向调用该函数的对象指针, 名为this, 从而使用成员函数知道该对哪个对象进行操作.
作用: 它将对象和该对象调用的成员函数连接在一起, 从外部看来, 每个对象都拥有自己的成员函数, 但处理这些数据成员的代码可以被所有的对象共享
this指针的实际形式
我们一般情况下都会省略this
// 定义一个类 class Point { double x; double y; public: // 有参构造函数 Point(double a = 0, double b = 0) { x = a; y = b; } // 成员函数 void display() { cout << x << ", " << y << endl; } // 伪代码 // void setXY(double x, double y Point * this) { // this -> x = x; // this -> y = y; // } // 我们可以写成这样 // void setXY(double x, double y) { // this -> x = x; // this -> y = y; // } // 但是一般我们都写成这样 void setXY(double x, double y) { x = x; y = y; } }; int main() { // 通过构造函数实例化对象 Point a(2, 3); // 调用成员函数 a.display(); }
一个类的对象作为另一个类的成员
因为类本身就是一种新的数据类型, 所以一个类的对象可以作为另一个类的成员
像这样：
// 类: Point, 包含两个数据成员 class Point { double x; double y; public: // 有参构造函数 Point(double a = 0, double b = 0) { x = a; y = b; } // 成员函数 void display() { cout << x << ", " << y << endl; } }; // 类: Line, 包含两个Point对象 class Line { // 两个为Point类的对象作为数据成员 Point startPoint; Point endPoint; public: // 构造函数 Line(Point start, Point end) { startPoint = start; endPoint = end; } // 成员函数 void display() { cout << "起点: "; startPoint.display(); cout << "终点: "; endPoint.display(); } // 返回一个Point对象: 起点 Point getStartPoint() { return startPoint; } // 返回一个Point对象: 终点 Point getEndPoint() { return endPoint; } }; int main() { // 通过构造函数实例化对象 Point a(2, 3); Point b(4, 5); // 通过已有对象实例化另一个对象 Line lineA(a, b); // 调用成员函数 lineA.display(); // 调用一个对象的成员函数, 返回另一个对象 Point startPoint = lineA.getStartPoint(); startPoint.display(); }
类和对象的性质
对象的性质
同一类的对象之间可以相互赋值
Point a(2, 3); Point b = a;复制代码
可以使用对象数组
Point arr[3];复制代码
可以使用指向对象的指针, 使用取地址运算符&将一个对象的地址赋值给该指针
Point p = &a;p -> display();复制代码
对象作为函数参数时, 可以使用对象, 对象引用和对象指针三种方式, 推荐使用对象的引用作为函数参数, 可以使用const修饰符保证原来的对象不被修改
void print(Point a) {} // 对象作为函数参数 void print(Point & a) {} // 对象引用作为函数参数 (推荐使用这一种) void print(Point * p) {} // 对象指针作为函数参数
一个对象可以作为另一个类的成员
class Point {} class Line { Point startPoint; Point endPoint; }
类的性质
使用类的权限
类本身的成员函数可以使用类的所有成员(私有和公有和受保护的成员)
类的对象只能访问公有成员函数
其它函数不能使用类的私有成员, 也不能使用公有成员函数
虽然一个类可以包含另一个类的对象, 但这个类也只能通过被包含的类对象使用成员函数, 再访问数据成员
不完全类的声明
class People; // 不完全的类声明
People * p; // 定义一个全局变量类指针
只有使用类产生对象时, 才进行内存分配
不完全类不能进行实例化, 否则编译出错, 我们使用得不是很多
空类
class Empty {};
可以不包括任何声明, 也可以没有任何行为, 但可以产生空类对象
像这样：
// 定义一个空类 class Empty { public: Empty(){}; }; int main() { // 产生空类对象 Empty e; }
作用: 在开发大型项目时, 需要在一些类还没有完全定义或实现时进行先期测试, 保证代码能正确地被编译, 当然我们有时也会给它一个无参构造函数, 来消除警告
类的作用域
声明类时使用的一对花括号{}形成类的作用域, 也包括类体外成员函数的作用域.
在类作用域中声明的标识符只在类中可见.
像这样：
// 定义类 class Example { int number; public: void setValue(int value) { // number在类作用域在内部所以有效, 可以使用 number = value; } void changValue(int); }; void Example::changValue(<#int#> value) { // 类的作用域也包括成员函数作用域, number有效 number = value; } //int a = number; // 错误, 因为这是在类作用域的外部, number无效 int number; // 正确, 这代码定义了一个全局变量number
总结
每个语言的类和对象其实大同小异, 可能一些名字不一样, 可能一些格式不一样, 但是思想是一样的, 例如一个对象的产生, 都得申请内存, 然后再对这块内存进行初始化, 有自己的属性, 还有自己的行为. 我们在学习的时候不要纠结于语言的本身, 要学会总结和自己已经学过的其它语言的异同点, 从而总结出规律, 提炼出本质, 这才是最主要的. 今天看到一段话送给大家, 大概是这么说的: 不是我们变老了就当不了程序员了, 而是因为我们不想学习了, 所以才显得我们变老了, 所以也就当不了程序员了！
自学C/C++编程难度很大，不妨和一些志同道合的小伙伴一起学习成长！
C语言C++编程学习交流圈子，【点击进入】微信公众号：C语言编程学习基地
有一些源码和资料分享，欢迎转行也学习编程的伙伴，和大家一起交流成长会比自己琢磨更快哦！
文章来源: 博客园
- 还没有人评论，欢迎说说您的想法！
客服
