c++要点

c++基础知识

  从一个基本的CMyString类讲起,分析了

    构造函数

    拷贝构造函数

    析构函数

    "="、"+="、"+"、左"++"、右"++"操作符重载

    "<<"输出流友元函数重载

  1、实现过程要关注内存泄露(析构)、非法输入值处理(“赋值重载”)、内存溢出异常处理(“赋值”重载)。

  2、操作符重载特别注意返回值类型和返回方式

 

  面向对象的三大特征:封装、继承和多态。多态特征将在工厂模式里强调。

class CMyString
{
public:
    CMyString(const char *pData = NULL)
    {
        /*
        构造函数
            作用:完成对象的初始化
            调用顺序:
                    a. 静态成员对象的构造函数。因为静态成员是与类直接相关的,在类内声明,在类的外部定义,并且只初始化一次。
                    b. 抽象基类的构造函数(按继承的顺序)
                    c. 虚拟基类的构造函数(按继承的顺序)
                    d. 非虚拟基类的构造函数(按继承的顺序)
                    e. 非静态成员对象的构造函数(按声明的顺序)
                    f. 调用类的构造函数。
        */
        if (pData == NULL)
        {
            m_pData = new char[1];
            m_pData[0] = \0;
        }
        else
        {
            //字符串数组的拷贝拷贝方式
            int length = strlen(pData);
            m_pData = new char[length + 1];
            strcpy(m_pData, pData);
        }
    }

    CMyString(const CMyString& str)
    {
        /*
         *    拷贝构造函数
         *        1、深拷贝与浅拷贝
         *            当类成员变量为指向堆空间的指针时,需要采用深拷贝,防止两个对象之间的干扰
         *        2、深拷贝过程
         *            为类成员指针分配新的堆上空间
         *            执行内容拷贝
         *
         */
        int length = strlen(str.m_pData);
        m_pData = new char[strlen(str.m_pData) + 1];
        strcpy(m_pData, str.m_pData);
    }

    ~CMyString(void)
    {
        /*
         *    析构函数
         *        1、默认析构函数
         *        2、当类成员使用堆上空间时,需要自定义析构函数,防止内存泄露
         */
        delete [] m_pData;    
    }

    CMyString& operator=(const CMyString& str)
    {
        /*
         *    =操作符重载
         *        1、要点
         *            a. 返回类型声明为该类型的引用,并且在函数结束前返回对象自身的引用(*this)
         *            b. 传入参数为常量引用
         *            c. 拷贝时首先需要释放堆上空间,防止内存泄露
         *            d. 判断参数对象与当前对象是不是同一个对象
         *        2、重载:匹配同名函数的参数列表,返回值类型不在考虑范围
         *        3、成员函数参数列表隐含了this指针,指向当前对象
         */

        if (this == &str)
        {
            //判断参数对象与当前对象是不是同一个对象
            return *this;
        }

        //释放堆上空间,防止内存泄露
        delete [] m_pData;
        m_pData = NULL;

        int length = strlen(str.m_pData);
        m_pData = new char[length + 1]; //bug: 当内存溢出时,抛出异常,对象失效
        strcpy(m_pData, str.m_pData);

        //返回对象自身的引用
        return *this;
    }

    CMyString& operator += (CMyString& rhs)
    {
        /*
         *    +=操作符重载
         *        1、返回当前类型的引用,函数结束时返回当前实例的引用*this
         */
        CMyString temp; //定义临时变量,防止内存溢出而抛出异常

        int length;
        length = strlen(m_pData) + strlen(rhs.m_pData);

        temp.m_pData = new char[length + 1];
        strcpy(temp.m_pData, m_pData);
        strcat(temp.m_pData, rhs.m_pData); //字符串的拼接
        
        char *pTemp = m_pData;
        m_pData = temp.m_pData;
        temp.m_pData = pTemp; //将当前实例的堆空间赋值给临时变量,在函数退出时析构

        return *this;
    }

    CMyString operator + (CMyString& rhs)
    {
        /*
         * + 操作符重载
         *         返回右值,也即将临时对象返回
         *         返回过程:
         *             a. 调用拷贝构造函数,生成匿名临时对象,用于返回
         *             b. 析构局部对象
         */

        CMyString ret;
        int length;

        length = strlen(m_pData) + strlen(rhs.m_pData);
        ret.m_pData = new char[length + 1];
        strcpy(ret.m_pData, m_pData);
        strcat(ret.m_pData, rhs.m_pData);
        
        return ret;
    }

    CMyString& operator ++()
    {
        /*
         *    前加
         *        返回引用,作为左值
         */
        int length;
        char *pTemp = m_pData;

        length = strlen(m_pData) * 2;

        m_pData = new char[length + 1];
        strcpy(m_pData, pTemp);
        strcat(m_pData, pTemp);

        delete [] pTemp;

        return *this;
    }

    CMyString operator ++(int rhs)
    {
        /*
         *    后加
         *        形参:标识重载函数
         *        返回值:返回对象,作为右值
         */
        CMyString ret = *this;

        int length;
        
        char *pTemp = m_pData;

        length = strlen(m_pData) * 2;

        m_pData = new char[length + 1];
        strcpy(m_pData, pTemp);
        strcat(m_pData, pTemp);
        
        delete [] pTemp;

        return ret;
    }

    //友元
    //    输出流重载
    //    作用:扩展外部函数的访问权限
    friend ostream& operator<< (ostream& os, const CMyString& str);

private:
    char *m_pData;
};

//友元函数的实现
ostream& operator<< (ostream& os, const CMyString& str)
{
    os << str.m_pData;
    return os;
}

 

    

c++要点,布布扣,bubuko.com

c++要点

上一篇:关于java对象的思考


下一篇:Windows常用快捷键