C++学习（2）-类和对象

1.类成员的可访问范围

private: 私有成员，只能在成员函数内访问
public : 公有成员，可以在任何地方访问
protected: 保护成员，以后再说

class className {
private:
    私有属性和函数
public:
    公有属性和函数
protected:
    保护属性和函数
};

如过某个成员前面没有上述关键字，则 $\color{red}{缺省地被认为是私有成员}$

在类的成员函数内部，能够访问：
-当前对象的全部属性，函数
-同类其他对象的全部属性、函数
在类的成员函数以外的地方，只能够访问该类对象的公有成员。
设置私有成员的机制，叫隐藏
隐藏”的目的是强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型等属性修改后，只需要更改成员函数即可。否则，所有直接访问成员变量的语句都需要修改。

2.成员函数的重载及参数缺省

成员函数也可以重载
成员函数可以带缺省参数
使用缺省参数要注意避免有函数重载时的二义性

#include <iostream>
using namespace std;
class Location {
private:
    int x, y;
public:
    void init(int x = 0, int y = 0);
    void valueX(int val) { x = val; }
    int valueX() { return x; }
};
void Location::init(int X, int Y)
{
    x = X;
    y = Y;
}
int main() {
    Location A, B;
    A.init(5);
    A.valueX(5);
    cout << A.valueX(); //5
    return 0;
}

3.构造函数

基本概念：
成员函数的一种
 名字与类名相同，可以有参数，不能有返回值(void也不行)
 作用是对对象进行初始化，如给成员变量赋初值
 如果定义类时没写构造函数，则编译器生成一个默认的无参数
的构造函数
•默认构造函数无参数，不做任何操作
 如果定义了构造函数，则编译器不生成默认的无参数的构造函数
 对象生成时构造函数自动被调用。对象一旦生成，就再也不能在
其上执行构造函数
一个类可以有多个构造函数

为什么需要构造函数：

构造函数执行必要的初始化工作，有了构造函数，就不
必专门再写初始化函数，也不用担心忘记调用初始化函数。
有时对象没被初始化就使用，会导致程序出错。
3）构造函数最好是public的，private构造函数不能直接用来初始化对象

4.构造函数在数组中的使用

class CSample {
    int x;
public:
    CSample() {
        cout << "Constructor 1 Called" << endl;
    }
    CSample(int n) {
        x = n;
        cout << "Constructor 2 Called" << endl;
    }
};
int main() {
    CSample array1[2];
    cout << "step1" << endl;
    CSample array2[2] = { 4,5 };
    cout << "step2" << endl;
    CSample array3[2] = { 3 };
    cout << "step3" << endl;
    CSample * array4 =
        new CSample[2];
    delete[]array4;
    return 0;
    /*
    Constructor 1 Called
    Constructor 1 Called
    step1
    Constructor 2 Called
    Constructor 2 Called
    step2
    Constructor 2 Called
    Constructor 1 Called
    step3
    Constructor 1 Called
    Constructor 1 Called
    */
}

class Test {
public:
    Test(int n) { } //(1)
    Test(int n, int m) { } //(2)
    Test() { } //(3)
};
Test array1[3] = { 1, Test(1,2) };
// 三个元素分别用(1),(2),(3)初始化
Test array2[3] = { Test(2,3), Test(1,2) , 1 };
// 三个元素分别用(2),(2),(1)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) };
//两个元素分别用(1),(2) 初始化

5.复制构造函数

基本概念
 只有一个参数,即对同类对象的引用。
 形如 X::X( X& )或X::X(const X &), 二者选一
后者能以常量对象作为参数
 如果没有定义复制构造函数，那么编译器生成默认
复制构造函数。默认的复制构造函数完成复制功能。
复制构造函数起作用的三种情况：

当用一个对象去初始化同类的另一个对象时。

Complex c2(c1);
Complex c2 = c1; //初始化语句，非赋值语句

如果某函数有一个参数是类 A 的对象，
那么该函数被调用时，类A的复制构造函数将被调用。

class A
{
public:
    A() { };
    A(A & a) {
        cout << "Copy constructor called" << endl;
    }
};
void Func(A a1) { }
int main() {
    A a2;
    Func(a2);
    return 0;
}

如果函数的返回值是类A的对象时，则函数返回时，A的复制构造函数被调用:

class A
{
public:
    int v;
    A(int n) { v = n; };
    A(const A & a) {
        v = a.v;
        cout << "Copy constructor called" << endl;
    }
};
A Func() {
    A b(4);
    return b;
}
int main() {
    cout << Func().v << endl; return 0;
}

6.类型转换构造函数

 定义转换构造函数的目的是实现类型的自动转换。
 只有一个参数，而且不是复制构造函数的构造函数，一般就可以看作是转换构造函数。
 当需要的时候，编译系统会自动调用转换构造函数，建立一个无名的临时对象(或临时变量)。

class Complex {
public:
    double real, imag;
    Complex(int i) {//类型转换构造函数
        cout << "IntConstructor called" << endl;
        real = i; imag = 0;
    }
    Complex(double r, double i) { real = r; imag = i; }
};
int main()
{
    Complex c1(7, 8);
    Complex c2 = 12;
    c1 = 9; // 9被自动转换成一个临时Complex对象
    cout << c1.real << "," << c1.imag << endl;
    return 0;
}

class Complex {
public:
    double real, imag;
    explicit Complex(int i) {//显式类型转换构造函数
        cout << "IntConstructor called" << endl;
        real = i; imag = 0;
    }
    Complex(double r, double i) { real = r; imag = i; }
};
int main() {
    Complex c1(7, 8);
    Complex c2 = Complex(12);
    c1 = 9; // error, 9不能被自动转换成一个临时Complex对象
    c1 = Complex(9) //ok
        cout << c1.real << "," << c1.imag << endl;
    return 0;
}

7.析构函数

名字与类名相同，在前面加‘~’ ，没有参数和返回值，一个类最多只能有一个析构函数。
析构函数对象消亡时即自动被调用。可以定义析构函数来在
对象消亡前做善后工作，比如释放分配的空间等。
如果定义类时没写析构函数，则编译器生成缺省析构函数。缺省析构函数什么也不做。
如果定义了析构函数，则编译器不生成缺省析构函数。

对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。
若new一个对象数组，那么用delete释放时应该写[].否则只delete一个对象（调用一次析构函数）