函数调用时的临时对象_C/C++编程笔记：C++入门知识丨类和对象
本篇要学习的内容和知识结构概览
类及其实例化
类的定义
将一组对象的共同特征抽象出来, 从而形成类的概念.
类包括数据成员和成员函数, 不能在类的声明中对数据成员进行初始化
声明类
形式为：
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++编程学习资料jq.qq.com微信公众号：C语言编程学习基地
软件下载
视频学习资料
有一些源码和资料分享，欢迎转行也学习编程的伙伴，和大家一起交流成长会比自己琢磨更快哦！