c++/oop---类和对象/构造函数

 

面向对象

简单的说就是写很多类

每个类有自己的数据和函数，叫做“成员”。

类定义出来的变量，也称为类的实例，就是“对象”。

和struct 好像差不多

对象之间有 '=' 关系，其他的需要定义

 

private: 私有成员，只能在成员函数内访问
public: 公有成员，可以在任何地方访问
protected: 保护成员，对于子女、朋友来说，就是public的，可以自由使用，没有任何限制，而对于其他的外部class，protected就变成private。

class 不写关键字默认是 private

struct 不写关键字默认是 public

三种关键字出现的次数和先后次序都没有限制

在类的成员函数内部，能够访问：
当前对象的全部属性、函数；
同类其它对象的全部属性、函数。
在类的成员函数以外的地方，只能够访问该类对象的公有成员

 

注：

（1）对成员函数在类外进行定义时，要加"类名 ::"

:: 作用域限定符

（2）类体中不能对所定义的数据成员初始化，应该通过构造函数初始化，但函数参数可以有初始值

 

构造函数
一种成员函数，名字与类名相同，可以有参数，不能有返回值
用于定义，一般为public

可以有多个构造函数，参数个数或类型不同

 

class Test {
2 public:
3 Test(int n) { } //(1)
4 Test(int n, int m) { } //(2)
5 Test() { } //(3)
6 };

函数后一定要加 {}

 

 

复制构造函数

只有一个参数，引用同类对象，无返回值，不定义的话系统默认一个

class node{
    public:
        int x=1,y=2;
        node (){ }
        node (const node &t){
            x=t.x,y=t.y*2;
        }
};
int main(){
    node a;
    a.x=1,a.y=2;
    node b(a);
    cout<<b.x<<' '<<b.y<<endl;
    // 1 4
    return 0;
}

改写为 node (const node & t) 即可以常量做参数，一般都这么写

如果没有复制构造函数，系统会默认一个全复制的，会完全一样

复制构造函数使用的情况：

b(a)

node b=a;(注意 node b;b=a; 不会调用构造复制函数，而调用 node 的构造函数)

f(node a) 

return a 

所以调用函数时会调用复制构造函数，可能会变慢

解决方法 f(node & a),避免 a 被改变就写 f(const node a)

 

类型转换构造函数

加explicit ，防止隐式自动转换

析构函数
名字与类名相同，在前面加‘∼’，没有参数和返回值

在对象消亡前做善后工作，比如释放分配的空间

delete x 只删一个

delete [] x 表示释放一整个数组的空间

参数、返回值的消亡也会调用析构函数

 

看一个例子

#include <iostream>
using namespace std;
class Sample {
    public:
        int v;
        Sample(int x=0){v = x;}
        Sample(const Sample & t){v=t.v+2;}
};
void PrintAndDouble(Sample o)
{
    cout << o.v;
    cout << endl;
}
int main()
{
    Sample a(5);
    Sample b = a;
    PrintAndDouble(b);
    Sample c = 20;
    PrintAndDouble(c);
    Sample d;
    d = a;
    cout << d.v;
    return 0;
}
//ans 9 22 5 

各种错误：

定义时没有 x = 0：无法执行 sample d;

定义时没有 const : 无法执行 Sample c = 20 ;