类

一.类成员函数的定义方法

1.在类声明中声明，类声明外定义

#include<iostream>
using namespace std;

class Person
{
public:
    void setAge(unsigned n);
    unsigned getAge() const;
private:
    unsigned age;
};

void Person::setAge(unsigned n)
{
    age = n;
}

unsigned Person::getAge() const
{
    return age;
}

int main()
{
    return 0;
}

2.在类声明中声明和定义

#include<iostream>
using namespace std;

class Person
{
public:
    void setAge(unsigned n)
    {
        age = n;
    }

    unsigned getAge() const
    {
        return age;
    }
private:
    unsigned age;
};

int main()
{
    return 0;
}

二.类声明通常放到.h文件中，不要将成员函数的定义放到.h中

三.一般来说应该采用引用的方式进行对象的传递和返回，而不要采用传值。传递一个指向对象的指针和引用方式效果相同，但引用语法简练。

四.const用法

const成员函数仅能调用其它const成员函数，非const成员函数可能会间接地改变对象状态

1.重载，2个成员函数（函数名，参数列表）一致，但一个有const一个无

不算重名，算重载

常对象调用常函数，非常对象调用非常函数

#include<iostream>
using namespace std;

class A
{
public:
    A()
    {
        x = 5;
    }
    int getValue()
    {
        return x;
    }

    int getValue() const
    {
        return 2 * x;
    }
private:
    unsigned x;
};

int main()
{
    A a1;
    const A a2;
    cout << a1.getValue() << endl; // 5
    cout << a2.getValue() << endl; // 10
    return 0;
}

2.三种const

#include<iostream>
using namespace std;

class C
{
public:
    void set(const int n)//set不会改变n
    {
        x = n;
    }

    const int& get() const//第一个const:get会返回一个const型引用，谁也不能通过这个引用修改x，不能修改返回值
    {                     //第二个const:get不会改变C中的数据成员
        return x;
    }
private:
    int x
};

int main()
{
    return 0;
}

若函数采用const返回，则返回值只赋给一个const类型局部变量；

const返回值是一个类的指针或者引用的话，则不能用该指针或者引用调用该类的non-const成员函数，因为这些函数可能会改变该类数据成员；

常量对象不能执行非常量成员函数。

#include<iostream>
using namespace std;

class C
{
public:
    int &f1()
    {
        mszt = 5;
        return mszt; // 可修改mstz，可修改返回值
    }

    int &f2() const
    {
        return a; // error，无法将const int转换为int&，去掉&
    }

    const int& f3()
    {
        a = 5;
        return a; //可修改a，不可修改返回值
    }

    void PrintMszt()
    {
        cout << mszt << endl;
    }

    void PrintA()
    {
        cout << a << endl;
    }
private:
    int mszt, a;
};

int main()
{
    C c;
    int &s = c.f3(); // error，s不是const
    const int& s1 = c.f3(); //ok
    cout << s1 << endl;
    s1 = 20;//error
    return 0;
}

3.对const成员不能直接赋值

#include <iostream>
#include <string>
using namespace std;

class C
{
public:
    C():c(0)//要用初始化列表
    {
        x = -1;
    }

private:
    const int c;
    int x;
};

int main()
{
    return 0;
}

五.构造函数

1.构造函数无返回类型，与类同名；

2.创建一个对象时，构造函数会被编译器自动调用；

3.希望只使用带参构造函数时，提供公有带参构造函数，而不提供默认构造函数，或者提供私有的默认构造函数

#include<iostream>
using namespace std;

class C
{
public:
    C(int a) {}
private:
    C() {}
};

int main()
{
    C c;//error
    C c(1);//OK
    return 0;
}

六.拷贝构造

Person(Person&); Person(const Person&);

拷贝构造函数可以有多于一个的参数，但第一个以后的所有参数都必须有默认值

Person(const Person& p, bool married = false);

若一个类包含指向动态存储空间指针类型的数据成员，应为这个类设计拷构。否则：

#include<iostream>
using namespace std;

class P
{
public:
    P();
    P(const string[], int);
    void set(const string[], int);
private:
    int size;
    string *p;
};

int main()
{
    string list[10];
    P p1(list, 3);
    P p2(p1);//默认拷构
    return 0;
}

p1.p和p2.p指向同一块存储空间，潜在p1的操作会改变p2，且调用析构时会对同一值析构两次。

#include<iostream>
using namespace std;

class C
{
public:
    C()
    {
        cout << "Default" << endl;
        num = 0;
    }

    C(const C &c)
    {
        cout << "Copy" << endl;
        //num = c.num;若有，若无
    }

    void set(int n)
    {
        num = n;
    }

    int get() const
    {
        return num;
    }
private:
    int num;
};

void f(C c4)//copy
{
    cout << "enter f(c)" << '	';
    c4.set(-999);
    cout << "c4:" << c4.get() << '	' << "leaving f(c)" << endl;
}

C g()
{
    cout << "enter g()" << endl;
    C c3;//default
    cout << "c3:" << c3.get() << '
';
    c3.set(123);
    cout << "c3:" << c3.get() << '	' << "leaving g()" << endl;
    return c3;//copy
}

int main()
{
    C c1, c2;//default
    cout << "c1:" << c1.get() << '	';
    cout << "c2:" << c2.get() << endl;
    f(c1);
    cout << "c1:" << c1.get() << endl;
    c2 = g();
    cout << "c2:" << c2.get() << endl;//若有123，若无乱码
    return 0;
}

用一个已存在的对象去构造一个不存在的对象（构造之前不存在）就是拷贝构造。用一个已存在的对象去覆盖另一个已存在的对象，就是赋值运算。

若对象很大，进行对象间的拷贝的话，非常费空间和时间，改进：

      把拷贝构造设计成私有成员；

      把void f(C c)=> void f(C &c)，C g()=>C &g()

七.转型构造函数（单参数构造函数）

#include<iostream>
using namespace std;

class Complex
{
public:
    Complex(int i)
    {
        cout << "Int Constructor" << endl;
        real = i, imag = 0;
    }

    Complex(double r, double i)
    {
        cout << "Double Constructor" << endl;
        real = r, imag = i;
    }

    Complex(Complex &c)
    {
        cout << "Copy Constructor" << endl;
        real = c.real;
        imag = c.imag;
    }

    int real, imag;
};

int main()
{
    Complex c1(7, 8);//Double Constructor
    Complex c2 = 12;//Int Constructor
    c1 = 9;//Int Constructor, 9隐式类型转换
    cout << c1.real << " " << c2.imag << endl;//9 0
    Complex c3 = c1;//Copy Constructor
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
    Person()
    {
        name = "Unknown";
    }

    Person(const string &n)//转型构造
    {
        cout << "转型" << endl;
        name = n;
    }

    Person(const char *n)//转型构造
    {
        cout << "转型" << endl;
        name = n;
    }

    Person(Person &p)//转型构造
    {
        cout << "Copy" << endl;
        name = p.name;
    }

    string name;
};

void f(Person p)
{
    cout << 1 << endl;
}

int main()
{
    Person s1("Dave");
    Person s2("Ben");
    string str = "Peter";
    f(str);//显示“转型”，不显示“转型”，在构造时，调用了转型构造函数
    s1 = str;//str转型为Person类型，显示“转型”
    s1 = s2;//什么都不显示，不存在Copy和转型
    return 0;
}

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
    Person()
    {
        name = "Unknown";
    }

    explicit Person(const string &n)//在转型构造函数前加上explicit，关闭隐式类型转换
    {
        name = n;
    }
private:
    string name;
};

int main()
{
    Person p("Dave");
    string b = "bar";
    p = b;//error
    return 0;
}

 

八.析构函数

析构函数没有参数和返回值，一个类最多一个析构函数

定义类时没写析构函数，则编译器生成缺省析构函数，不涉及释放用户申请的内存释放等清理工作。

#include<iostream>
using namespace std;

class C
{
public:
    C()
    {
        cout << "Construct" << endl;
    }
    ~C()
    {
        cout << "Destructor" << endl;
    }
};

int main()
{
    C c1[2], *c2 = new C[3];
    return 0;
}
/*
Construct
Construct
Construct
Construct
Construct
Destructor
Destructor
*/

#include<iostream>
using namespace std;

class C
{
public:
    C()
    {
        cout << "Construct" << endl;
    }
    ~C()
    {
        cout << "Destructor" << endl;
    }
};

int main()
{
    C *c2 = new C[3];
    delete[] c2;
    return 0;
}
/*
Construct
Construct
Construct
Destructor
Destructor
Destructor
*/