c++基础(6)——c++类与对象基础

1.类的研究

• 研究 C++编译器管理类和对象的方法 ===》避免死角
• c++编译器对类对象的生命周期管理，对象创建、使用、销毁
• c++面向对象模型初探
• c++面向对象多态原理探究
• 操作符重载

struct 和 class 关键字区别

• 在用 struct 定义类时，所有成员的默认属性为 public
• 在用 class 定义类时，所有成员的默认属性为 private

构造函数定义及调用

1）C++中的类可以定义与类名相同的特殊成员函数，这种与类名相同的成员函数叫做构
造函数
2）没有任何返回类型的声明
3）一般情况下 C++编译器会自动调用构造函数,在一些情况下则需要手工调用构造函数

析构函数定义及调用
1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函
数,语法：~ClassName()
2）析构函数没有参数也没有任何返回类型的声明
3）析构函数在对象销毁时自动被调用

例子：

class Counter
{
public:
     // 类Counter的构造函数
     // 特点：以类名作为函数名，无返回类型
     Counter()
     {
            m_value = 0;
     }
private:
      // 数据成员
     int m_value;
}

该类对象被创建时，编译系统为对象分配内存空间，并自动调用该构造函数->由构造函数完成成员的初始化工作
Counter c1;
编译系统为对象c1的每个数据成员(m_value)分配内存空间，并调用构造函数Counter( )自动地初始化对象c1的m_value值设置为0
故：构造函数的作用：初始化对象的数据成员。

二、 构造函数的种类

1.无参数构造函数
2.一般带参构造函数
3.复制构造函数
4.赋值构造函数

class Complex
{        
private :
    double    m_real;
    double    m_imag;
public:
    //    无参数构造函数
    // 如果创建一个类你没有写任何构造函数,则系统会自动生成默认的无参构造函数，函数为空，什么都不做
    // 只要你写了一个下面的某一种构造函数，系统就不会再自动生成这样一个默认的构造函数，如果希望有一个这样的无参构造函数，则需要自己显示地写出来
    Complex(void)
    {
         m_real = 0.0;
         m_imag = 0.0;
    }  
    //    一般构造函数（也称重载构造函数）
    // 一般构造函数可以有各种参数形式,一个类可以有多个一般构造函数，前提是参数的个数或者类型不同（基于c++的重载函数原理）
    // 例如：你还可以写一个 Complex( int num)的构造函数出来
    // 创建对象时根据传入的参数不同调用不同的构造函数
    Complex(double real, double imag)
    {
         m_real = real;
         m_imag = imag;        
     }
     
     //也可以写成序列化初始模式，如下：
    // Complex(double real, double imag): m_real(real),m_imag(imag) {}
      
    //    复制构造函数（也称为拷贝构造函数）
    //    复制构造函数参数为类对象本身的引用，用于根据一个已存在的对象复制出一个新的该类的对象，一般在函数中会将已存在对象的数据成员的值复制一份到新创建的对象中
    //    若没有显示的写复制构造函数，则系统会默认创建一个复制构造函数，但当类中有指针成员时，由系统默认创建该复制构造函数会存在风险，具体原因请查询 有关 “浅拷贝” 、“深拷贝”的文章论述
    Complex(const Complex & c)
    {
            // 将对象c中的数据成员值复制过来
            m_real = c.m_real;
            m_imag    = c.m_imag;
    }           
        // 类型转换构造函数，根据一个指定的类型的对象创建一个本类的对象，
     //需要注意的一点是，这个其实就是一般的构造函数，但是对于出现这种单参数的构造函数，C++会默认将参数对应的类型转换为该类类型，有时候这种隐私的转换是我们所不想要的，所以需要使用explicit来限制这种转换。
       // 例如：下面将根据一个double类型的对象创建了一个Complex对象
       Complex(double r)
        {
                m_real = r;
                m_imag = 0.0;
        }
        // 等号运算符重载（也叫赋值构造函数）
        // 注意，这个类似复制构造函数，将=右边的本类对象的值复制给等号左边的对象，它不属于构造函数，等号左右两边的对象必须已经被创建
        // 若没有显示的写=运算符重载，则系统也会创建一个默认的=运算符重载，只做一些基本的拷贝工作
        Complex &operator=( const Complex &rhs )
        {
                // 首先检测等号右边的是否就是左边的对象本身，若是本对象本身,则直接返回
                if ( this == &rhs )
                {
                        return *this;
                }               
                // 复制等号右边的成员到左边的对象中
                this->m_real = rhs.m_real;
                this->m_imag = rhs.m_imag;               
               // 把等号左边的对象再次传出
               // 目的是为了支持连等 eg:    a=b=c 系统首先运行 b=c
               // 然后运行 a= ( b=c的返回值,这里应该是复制c值后的b对象)    
                return *this;
        }
};

下面使用上面定义的类对象来说明各个构造函数的用法：

int main()
{
    // 调用了无参构造函数，数据成员初值被赋为0.0
    Complex c1，c2;

    // 调用一般构造函数，数据成员初值被赋为指定值
    Complex c3(1.0,2.5);
    // 也可以使用下面的形式
    Complex c3 = Complex(1.0,2.5);
   
    //    把c3的数据成员的值赋值给c1
    //    由于c1已经事先被创建，故此处不会调用任何构造函数
    //    只会调用 = 号运算符重载函数
    c1 = c3;       
    //    调用类型转换构造函数
    //    系统首先调用类型转换构造函数，将5.2创建为一个本类的临时对象，然后调用等号运算符重载，将该临时对象赋值给c1
    c2 = 5.2;       
   // 调用拷贝构造函数( 有下面两种调用方式)
    Complex c5(c2);
    Complex c4 = c2;  // 注意和 = 运算符重载区分,这里等号左边的对象不是事先已经创建，故需要调用拷贝构造函数，参数为c2
//这一点特别重要，这儿是初始化，不是赋值。其实这儿就涉及了C++中的两种初始化的方式：复制初始化和赋值初始化。其中c5采用的是复制初始化，而c4采用的是赋值初始化，这两种方式都是要调用拷贝构造函数的。
}

浅拷贝和深拷贝

如果没有自定义复制构造函数，则系统会创建默认的复制构造函数，但系统创建的默认复制构造函数只会执行“浅拷贝”，即将被拷贝对象的数据成员的 值一一赋值给新创建的对象，若该类的数据成员中有指针成员，则会使得新的对象的指针所指向的地址与被拷贝对象的指针所指向的地址相同，delete该指针 时则会导致两次重复delete而出错。下面是示例：

#include <iostream.h>
#include <string.h>
class Person
{
public :
     // 构造函数
    Person(char * pN)
    {
          cout << "一般构造函数被调用 !\n";
          m_pName = new char[strlen(pN) + 1];
          //在堆中开辟一个内存块存放pN所指的字符串
          if(m_pName != NULL)
          {
             //如果m_pName不是空指针，则把形参指针pN所指的字符串复制给它
               strcpy(m_pName ,pN);
          }
    }        
   
    // 系统创建的默认复制构造函数，只做位模式拷贝
    Person(Person & p)    
    {
              //使两个字符串指针指向同一地址位置        
             m_pName = p.m_pName;        
    }
     ~Person( )
    {
            delete m_pName;
    }
private :

    char * m_pName;
};

void main( )
{
    Person man("lujun");
    Person woman(man);
   
    // 结果导致   man 和    woman 的指针都指向了同一个地址
   
    // 函数结束析构时
    // 同一个地址被delete两次
}
// 下面自己设计复制构造函数，实现“深拷贝”，即不让指针指向同一地址，而是重新申请一块内存给新的对象的指针数据成员
Person(Person & chs);
{
     // 用运算符new为新对象的指针数据成员分配空间
     m_pName=new char[strlen(p.m_pName)+ 1];

     if(m_pName)        
     {
             // 复制内容
            strcpy(m_pName ,chs.m_pName);
     }
 
    // 则新创建的对象的m_pName与原对象chs的m_pName不再指向同一地址了
}

构造函数初始化列表

    1. 一个类中包含另外一个类的成员，则必须使用初始化列表(进入构造函数体内前)，调用该类的构造函数进行初始化
    2.类成员中若有 const 修饰，必须在对象初始化的时候，给 const int m 赋值
      当类成员中含有一个 const 对象时，或者是一个引用时，他们也必须要通过成员初始化列表进行初始化
例子:

#include "iostream"
#include <stdio.h>
#include <stdlib.h>

using namespace std;
class ABC
{
public:
    ABC(int a, int b, int c)
    {
        this->a = a;
        this->b = b;
        this->c = c;
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("ABC construct ..\n");
    }
    ~ABC()
    {
        printf("a:%d,b:%d,c:%d \n", a, b, c);
        printf("~ABC() ..\n");
    }
protected:
private:
    int a;
    int b;
    int c;
};
class MyD
{
public:
    //当类中有成员变量是其它类的对象时,首先调用成员变量的构造函数
    //当类中有const成员变量或引用时,必须在对象初始化列表(进入构造函数体内前)，给 const int m 赋值
    MyD():abc1(1,2,3),abc2(4,5,6),m(100)
    //MyD()
    {
        cout<<"MyD()"<<endl;
    }
    ~MyD()
    {
        cout<<"~MyD()"<<endl;
    }
protected:
private:
    ABC abc1; //c++编译器不知道如何构造 abc1
    ABC abc2;
    const int m;
};
int run()
{
    MyD myD;
    return 0;
}
int main()
{
    run();
    system("pause");
    return 0;
}

结果:

a:1,b:2,c:3
ABC construct ..
a:4,b:5,c:6
ABC construct ..
MyD()
~MyD()
a:4,b:5,c:6
~ABC() ..
a:1,b:2,c:3
~ABC() ..

结论:
构造函数与析构函数的调用顺序
1）当类中有成员变量是其它类的对象时，首先调用成员变量的构造函数，调用顺序与
声明顺序相同；之后调用自身类的构造函数
2）析构函数的调用顺序与对应的构造函数调用顺序相反

类的静态成员变量

1.静态成员提供了一个同类对象的共享机制
  把一个类的成员说明为 static 时，这个类无论有多少个对象被创建，这些对象共
  享这个 static 成员

2.静态成员是属于类的，它不是对象成员
  调用的2种方式:  类名::变量名;
                  对象名.变量名;3.静态成员需要在类外进行初始化
例子1:

#include<iostream>
using namespace std;

class counter
{
static int num ; //声明与定义静态数据成员
public :
    void setnum ( int i ) { num = i ; } //成员函数访问静态数据成员
    void shownum() { cout << num << '\t' ; }
} ;
int counter :: num = 0 ;//在类外对静态成员初始化

void main ()
{
    counter a , b ;
    a.shownum() ; //调用成员函数访问私有静态数据成员
    b.shownum() ;
    a.setnum(10) ;
    a.shownum() ;
    b.shownum() ;
}

结果:

例子2：

#include<iostream.h>
class counter
{
public :
    counter (int a) { mem = a; }
    int mem; //公有数据成员
    static int Smem ; //公有静态数据成员
} ;
int counter :: Smem = 1 ; //初始值为 1

void main()
{
    counter c(5);
    int i ;
    for( i = 0 ; i < 5 ; i ++ )
    {
        counter::Smem += i ;
        cout << counter::Smem << '\t' ; //访问静态成员变量方法 2
    }
    cout<<endl;
    cout<<"c.Smem = "<<c.Smem<<endl; //访问静态成员变量方法 1
    cout<<"c.mem = "<<c.mem<<endl;
}

类的静态成员函数

1. 静态成员函数提供不依赖于类数据结构的共同操作，它没有 this 指针
2. 在类外调用静态成员函数用 “类名 :: ”作限定词，或通过对象调用
3. 静态成员函数可以在类内声明，类外实现，此时类外前面不能写static
4. 静态成员函数中，不能使用普通变量。
   静态成员变量属于整个类的，分不清楚不同变量是属于那个对象的

#include "iostream"
#include <stdio.h>
#include <stdlib.h>

using namespace std;
class BB
{
public:
    //通过公有的成员函数访问私有的成员变量
    //私有的成员变量无法在类外直接使用
    int getC()
    {
        return c;
    }

    int getA()
    {
        return a;
    }

    void setC(int myc)
    {
        c=myc;
    }
    //在类内声明定义静态成员函数
    static void setA(int i,BB *ptr);
    //在类内定义并实现静态成员函数
    static void getMen()
    {
        //静态成员函数不能使用普通变量
        //cout<<a<<endl;
        //可以使用静态成员变量，因为都属于类的
        cout<<c<<endl;
    }
protected:

private:
    int a;
    int b;
    static int c;
};
//在类外初始化成员变量
int BB::c=0;

//在类外实现静态成员函数
//静态成员函数通过传参的方式，使用对象的普通变量。
void BB::setA(int i, BB *ptr)
{
    ptr->a = i;
}

int main()
{
    BB b1;
    BB b2;
    cout<<b2.getC()<<endl;
    b1.setC(100);
    cout<<b2.getC()<<endl;

    BB b3;
    //方式1:通过类的方式使用静态成员函数
    BB::setA(3,&b3);
    cout<<b3.getA()<<endl;
    //方式2: 通过对象的方式调用静态成员函数
    b3.setA(4,&b3);
    cout<<b3.getA()<<endl;

    return 0;
}