类和对象（2）

类成员的可访问范围

在类的定义中，用下列访问范围关键字来说明类成员可被访问的范围:

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

如果某个成员前面没有上述关键字，则缺省的被默认为是私有成员。

class Man{
  int nAge;//私有成员
  char szName[20];//私有成员
  public：
    void SetName(char * szName){
      strcpy(Man::szName,szName);
    }
}

在类的成员函数内部，能够访问:

当前对象的全部属性、函数；
同类其他对象的全部属性、函数。
在类的成员函数以外的地方，只能够访问该类对象的公有成员。一个例子如下:

class CEmployee{
    private:
        char szName[30];
    public:
        int salary;
        void setName(char *name);
        void getName(char *name);
        void averageSalary(CEmployee e1,CEmployee e2);
};
void CEmployee::setName(char *name){
    strcpy(szName,name);//ok
}

void CEmployee::getName(char *name){
    strcpy(name,szName);//ok
}

void CEmployee::averageSalary(CEmployee e1,CEmployee e2){
    cout << e1.szName;
    salary = (e1.salary + e2.salary)/2;
}

int main()
{
    CEmployee e;
    strcpy(e.szName,"Tom1234567889");//编译错，不能访问私有成员
    e.setName("Tom"); //ok
    e.salary = 5000;//ok
    return 0;
}

设置私有成员的机制，叫“隐藏”
“隐藏”的目的是强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型属性修改后，只需要更改成员函数即可。否则，所有访问成员变量的语句都需要修改。

“隐藏”的作用

如果将上述的程序移植到内存紧张的手持设备上，希望将szName改为szName[5],若szName不是私有，那么就要找出所有类似于 strcpy(e.szName,”Tom1234567899”); 这样的语句进行修改，以防止数组越界。这样做很麻烦。
如果将szName变为私有，那么程序中就不可能再出现strcpy(e.szName,”Tom1234567899”);所有对szName的访问都是通过成员函数来进行，比如:
e.setName(“Tom1234567899”);
那么，就算szName改短了，上面的语句也不需要找出来修改，只要改setName成员函数，在里面确保不越界就可以了。

用struct定义类

struct CEmployee{
       char szName[30];//公有
   public:
       int salary;
       void setName(char *name);
       void getName(char *name);
       void averageSalary(CEmployee e1,CEmployee e2);
}

和class的唯一区别是，就是未说明是公有还是私有的成员，就是公有。

成员函数的重载和参数缺省

成员函数也可以重载。
成员函数可以带缺省参数。

#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();
	return 0;
}

输出结果为5
注意：使用缺省参数要注意避免有函数重载时的二义性

class Location {
private :
int x, y;
public:
void init( int x =0, int y = 0 );
void valueX( int val = 0) { x = val; }
int valueX() { return x; }
};
Location A;
A.valueX(); //错误，编译器无法判断调用哪个valueX

构造函数

基本概念

是成员函数的一种：1.名字与类名相同，可以有参数，不能有返回值（void也不行）；2.作用是对对象进行初始化，如给成员变量赋初值；3.如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数：默认构造函数无参数，不做任何操作。
如果定义了构造函数，则编译器不生成默认的无参数的构造函数。
对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数。
一个类可以有多个构造函数。
为什么需要构造函数：
1.构造函数执行必要的初始化工作，有了构造函数，就不必专门再写初始化函数，也不用忘记调用初始化函数。
2.有时对象没被初始化就使用，会导致程序出错。

class Complex{
private:
    double real,imag;
public:
    void Set(double r,double i);
};//编译器自动生成默认的构造函数

Complex c1;//默认构造函数被调用
Complex *pc = new Complex;//默认构造函数被调用


class Complex{
private:
    double real,imag;
public:
    Complex(double r,double i = 0);
};
Complex::Complex(double r,double i){ // 构造函数
    real = r;
    imag = i;
}
Complex c1;//error,缺少构造函数的参数
Complex *pc = new Complex;//error,没有参数
Complex c1(2);//OK
Complex c1(2,4),c2(3,5);
Complex *pc = new Complex(3,4);

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

class Complex{
private:
    double real,imag;
public:
    void Set(double r,double i);
    Complex(double r,double i);
    Complex(double r);
    Complex(Complex c1,Complex c2);
};

Complex::Complex(double r,double i){
    real = r;imag = i;
}

Complex::Complex(double r){
    real = r;
    imag = 0;
}

Complex::Complex(Complex c1,Complex c2){
    real = c1.real+c2.real;
    imag = c1.imag+c2.imag;
}
Complex c1(3),c2(1,0),c3(c1,c2);
//c1 ={3,0},c2={1,0},c3={4,0};

构造函数最好是public的，private的构造函数不能直接用来初始化对象

class CSample{
private:
    CSample(){
    }
};
int main(){
    CSample Obj;//err.唯一的构造函数是private
    return 0;
}

构造函数在数组中的使用

class CSample{
    int x;
public:
    CSample(){
        cout << "Constructor 1 Called"<<endl;
    }
    CSample(int n){
        x = n;
        cout << "Constructed 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)初始化

复制构造函数

基本概念

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

class Complex{
private:
    double real,imag;
};
Complex c1;//调用缺省无参构造函数
Complex c2(c1);//调用缺省的复制构造函数，将c2初始化成和c1一样

如果定义的自己的复制构造函数，则默认的复制构造函数不存在。

class Complex{
public:
    double real,imag;
Complex(){}
Complex(const Complex &c){
    real = c.real;
    imag = c.imag;
    cout << "Copy Constructor called";
}
};
Complex c1;
Complex c2(c1);//调用自己定义的复制构造函数，输出Copy Constructor called

不允许有形如X::X(X)的构造函数。

class CSample{
    CSample(CSample c){
    }//错，不允许这样的构造函数
};

复制构造函数起作用的三种情况

1）当用一个对象去初始化同类的另一个对象时。
Complex c2(c1);
Complex c2=c1;//初始化语句，非赋值语句
2）如果某函数有一个参数是类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;
}

程序输出结果为:Copy constructor called
3)如果函数的返回值是类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;
}
输出结果：
Copy constructor called
4 6

注意:对象间赋值并不导致复制构造函数被调用

class CMyclass{
public:
    int n;
    CMyclass() {};
    CMyclass(CMyclass &c){
        n = 2*c.n;
    }
};

int main(){
    CMyclass c1,c2;
    c1.n = 5;
    c2 = c1;
    CMyclass c3(c1);
    cout << "c2.n="<<c2.n<<",";
    cout << "c3.n="<<c3.n<<endl;
    return 0;
}
输出： c2.n=5,c3.n=10

常量引用参数的使用

1
2
3

void fun(Cmyclass obj_){
    cout <<"fun"<<endl;
}

这样的函数，调用时生成形参会引发复制构造函数的调用，开销比较大。
所以可以考虑使用CMyclass &引用类型作为参数。
如果希望确保实参的值在函数中不应被改变，可以加上const关键字：

1
2
3

void fun(const CMyclass &obj){
    //函数中任何试图改变obj值的语句都将是变成非法。
}

类型转换构造函数

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

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;
}

析构函数

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

class String{
private:
    char *p;
public:
    String(){
        p = new char[10];
    }
    ~ String();
};

String::~ String()
{
    delete []p;
}

对象数组生命期结束时，对象数组的每个元素的析构函数都会被调用。

class Ctest{
public:
    ~Ctest(){
        cout<<"destructor called"<<endl;
    };
};
int main(){
    Ctest array[2];
    cout <<"End Main"<<endl;
    return 0;
}
输出:
End Main
destructor called
destructor called

delete 运算导致析构函数调用。

Ctest *pTest;
pTest = new Ctest;//构造函数调用
delete pTest;//析构函数调用

pTest = new Ctest[3];//构造函数调用3次
delete []pTest;//析构函数调用3次

若new一个对象数组，那么用delete释放时应该写[]。否则只delete一个对象(调用一次析构函数)
析构函数在对象作为函数返回值后被调用

class CMyclass{
public:
    ~CMyclass(){
        cout << "destructor"<< endl;
    };
};
CMyclass obj;
CMyclass fun(CMyclass sobj){//参数对象消亡也会导致析构函数被调用
    return sobj;//函数调用返回时生成临时对象返回
}
int main(){
    obj = fun(obj);//函数调用的返回值（临时对象）被用过后，该临时对象析构函数被调用
    return 0;
}
输出:
destructor
destructor
destructor

析构函数和析构函数什么时候被调用

class Demo{
    int id;
public:
    Demo(int i){
        id = i;
        cout << "id="<<id<<" constructed"<<endl;
    }
    ~Demo(){
        cout << "id="<<id<<" destructed"<<endl;
    }
};

Demo d1(1);
void Func(){
    static Demo d2(2);
    Demo d3(3);
    cout << "func"<<endl;
}
int main(){
    Demo d4(4);
    d4 = 6;
    cout << "main"<<endl;
    {
        Demo d5(5);
    }
    Func();
    cout <<"main ends"<<endl;
    return 0;
}
输出依次为:
id=1 constructed
id=4 constructed
id=6 constructed
id=6 destructed
main
id=5 constructed
id=5 destructed
id=2 constructed
id=3 constructed
func
id=3 destructed
main ends
id=6 destructed
id=2 destructed
id=1 destructed

关于复制构造函数和析构函数的又一个例子

class CMyclass{
public:
    CMyclass(){};
    CMyclass(CMyclass & c){
        cout << "copy constructor"<<endl;
    }
    ~CMyclass(){
        cout << "destructor"<< endl;
    }
};
void fun(CMyclass obj_){
    cout << "fun"<<endl;
}
CMyclass c;
CMyclass Test(){
    cout<<"test"<<endl;
    return c;
}
int main(){
    CMyclass c1;
    fun(c1);
    Test();
    return 0;
}
输出结果：
copy constructor
fun
destructor //参数消亡
test
copy constructor
destructor // 返回值临时对象消亡
destructor // 局部变量消亡
destructor // 全局变量消亡