C++类和动态内存分配

注：本文章仅供个人复习使用。
在这里定义了一个String类，并重载了各种操作符。
String.h:

#include <iostream>#ifndef STRNGBAD_H_#define STRNGBAD_H_class String{private:    char * str;    int len;    static int num_strings; //静态类成员，所有对象共享一个静态成员    static const int CINLIM = 80;public:    String(const char * s);    String();    ~String();    String(const String & st); //复制构造函数    int length()const{return len;}  //内联函数    String & operator=(const String & st);  //赋值操作符只能由类成员函数重载    String & operator=(const char *);    char & operator[](int i);  //[]下标操作法只能有类成员函数重载    const char & operator[](int i)const;    friend std::ostream & operator<<(std::ostream & os,const String &st);    friend bool operator<(const String &st1,const String &st2);    friend bool operator>(const String &st1,const String &st2);    friend bool operator==(const String &st1,const String &st2);    friend std::ostream & operator<<(std::ostream & os,const String & st);    friend std::istream & operator>>(std::istream & is,String & st);    static int HowMany();};#endif

String.cpp:

#include <cstring>#include "String.h"//initializing static class memberint String::num_strings = 0;//class methods//construct StringBad from C stringString::String(const char * s){    len = std::strlen(s);    str = new char[len + 1];    std::strcpy(str,s);    num_strings++;    //std::cout<<num_strings<<": \""<<str<<"\"object created\n";}String::String(){    len = 4;    str = new char[1];    //std::strcpy(str,"C++");    str[0] = '\0';    num_strings++;    //std::cout<<num_strings<<": \""<<str<<"\"default object created\n";}String::String(const String & st){    num_strings++;    len = st.len;    str = new char[len + 1];    std::strcpy(str,st.str);    //std::cout<<num_strings<<": \""<<str<<"\"object created\n";}String::~String()  //必须要有析构函数！！！{    //std::cout<<"\""<<str<<"\"object deleted, ";    --num_strings;    //std::cout<<num_strings<<" left\n";    delete [] str;}String & String::operator=(const String & st){    if(this == &st)        return *this;    delete[] str;    len = st.len;    str = new char [len + 1];    std::strcpy(str,st.str);    return *this;}String & String::operator=(const char * s){    delete []str;    len = std::strlen(s);    str = new char[len + 1];    std::strcpy(str,s);    return *this;}char & String::operator[](int i){    return str[i];}const char & String::operator[](int i)const{    return str[i];}bool operator<(const String & st1,const String & st2){    return (std::strcmp(st1.str,st2.str) < 0);}bool operator>(const String & st1,const String & st2){    return st2.str < st1.str;}bool operator==(const String & st1,const String & st2){    return (std::strcmp(st1.str,st2.str) == 0);}std::ostream & operator<<(std::ostream & os,const String & st){    os<<st.str;    return os;}std::istream & operator>>(std::istream & is,String & st){    char temp[String::CINLIM];    is.get(temp,String::CINLIM);    if(is)        st = temp;    while(is && is.get()!='\n')        continue;    return is;}int String::HowMany(){    return num_strings;}

以上是对String类里的成员函数的定义，这里要注意的是定义了三个构造函数用来初始化String类对象，而且都是用new来动态分配的内存，所以一定要用delete来释放内存。如果是用的new[ ]来分配内存，则需要用delete[ ]来释放内存。
下面主要说一下复制构造函数，当使用一个对象来初始化另外一个对象时，编译器会自动生成复制构造函数。具体来说C++自动提供了下面这些成员函数：

• 默认构造函数，如果程序员没有定义构造函数。
• 复制构造函数，如果程序员没有定义。
• 赋值操作符，如果程序员没有定义。
• 默认析构函数，如果程序员没有定义。
• 地址操作符，如果程序员没有定义。

1.默认构造函数
如果没有提供任何构造函数，C++将创建默认构造函数例如：String::String( ){ }，也就是说编译器将提供一个不接受任何参数，也不执行任何操作的构造函数，这是因为创建对象时总是会调用构造函数。

2.复制构造函数
复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用与初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下：
class_name (const class_name &);
它接受一个指向类对象的常量作为引用参数，例如，String类的复制构造原型如下：
String (const String &);
对于复制构造函数，需要知道两点：何时调用，有何功能。

（1）何时调用复制构造函数
新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。例如假设metoo是一个String类的对象，则下面四种声明都将调用复制构造函数：
String ditto (metoo);
String metoo = motoo;
String also = String (motto);
String * pString = new String (motoo);
当函数按值传递对象或返回对象时，都将使用复制构造函数。记住，按值传递意味着创建原始变量的一个副本。由于按值传递对象将调用复制构造函数，因此应该按引用传递对象。

（2）复制构造函数的功能
默认的复制构造函数逐个复制非静态成员（成员复制也称为浅复制），复制的是成员的值。下述语句
String a = b;
与下面的代码等效
String a;
a.str = b.str;
a.len = b.len;
如果成员本身就是类对象，则将使用这个类的复制构造函数来复制成员对象。静态函数不受影响，因为它们属于整个类，而不是各个对象。

（3）复制构造函数哪里出了问题？
默认的复制构造函数不说明其行为，因此它不指出创建进程，也不增加计数器num_strings的值。但是析构函数更新了记数，并且在任何对象过期时都将被调用，而不管对象是如何被创建的。

上图表示了用默认的复制构造函数来逐个复制成员。

两个指针指向同一个字符串，但显示时不会有问题，但是当释放这两个指针所指向
的内存就会出现问题，先释放ditto.str指针指向的内存
delete [ ] ditto.str;
这里没有问题，再释放motoo.str指针指向的内存
delete [ ] motoo.str；
这里就会出现问题，它试图释放已经被释放过的内存。这将导致不确定的，可能有害的后果。

（4）.使用显示复制的构造函数来解决问题
解决上述问题的方法是进行深度复制。也就是说，复制构造函数应当复制字符串并将副本的地址赋给str成员，而不仅仅是复制字符串地址。这样每个对象都有自己的字符串，而不是引用另一个对象的字符串。调用析构函数时都将释放不同的字符串，而不会试图去释放已经被释放的字符串。可以这样编写Sting类的复制构造函数：

String::String (const String & st){    num_strings++;    len = st.len;    str = new char[len + 1];    std::strcpy(str,st.str);}

必须定义复制构造函数的原因在于，一些类成员是使用new初始化的、指向数据的指针，而不是数据本身，
下图说明了深度复制

深度复制
注意：如果类中包含了使用new初始化的指针成员，应当定义一个复制构造函数，以复制指向的数据，而不是指针，这被称为深度复制。浅复制只是复制指针值。

3.赋值操作符
并不是所有的问题都归咎于默认的复制构造函数，还需要看一看默认的赋值操作符：
class_name & class_name::operator=(const class_name &);
它接受并返回一个指向类对象的引用。

（1）何时使用赋值操作符
将已有的对象赋给另一个对象时，将使用重载的赋值操作符：
String a(“I’m ZhaoLong.”);
…
String b;
b = a;
初始化对象时，并不一定会使用赋值操作符：
String b = a;
这里a是一个新创建的对象，被初始化为b的值，因此使用复制构造函数。不过，实现时也可能分成两步：使用复制构造函数来创建一个临时对象，然后通过赋值将临时对象的值复制到新对象中。这就是说，初始化总是会调用复制构造函数，而使用 = 操作符时也可能调用赋值操作符。

（2）赋值操作符的功能
与复制构造函数相似，赋值操作符的隐式实现也对成员进行逐个复制。如果成员本身就是类对象，则程序将使用为这个类定义的赋值操作符来复制该成员，但静态数据成员不受影响。

（3）赋值的问题在哪里？
与隐式复制构造函数相同：数据受损。这也是成员复制的问题，即导致motoo.str 和 ditto.str指向相同的地址。

（4）解决赋值的问题
对于默认赋值操作符不合适而导致的问题，解决方法是提供赋值操作符（进行深度复制）定义。其实现与复制构造函数相似，但也有一些差别。

• 由于目标对象可能引用了以前分配的数据，所以函数应使用delete [ ]来释放这些数据。
• 函数应当避免将对象赋给自身；否则，给对象重新赋值之前，释放内存操作可能删除对象的内容。
• 函数返回一个指向调用对象的引用。
  下面代码说明了如何为String类编写赋值操作符：

String & String::operator=(const String & st){    if(this == &st)        return *this;    delete [ ] str;    len = st.len;    str = new char [len+1];    std::strcpy(str,st.str);    return *this;}

代码首先检测自我复制，这是通过查看赋值操作符右边的地址（&st）是否与接收对象（this）的地址相同来完成的。如果相同，程序将返回*this，然后结束。前面介绍过，赋值操作符是只能有类成员函数重载的操作符之一。

如果地址不同，函数释放str指向的内存，这是因为稍后将把一个新字符串的地址赋给str。如果不首先使用delete操作符，则上述字符串将保留在内存中，由于程序中不再包含指向该字符串的指针，因此这些内存会被浪费掉。

接下来的操作与复制构造函数相似，即为新字符串分配足够的内存空间，然后将赋值操作符右边的对象中的字符串赋值到新的内存单元中，并返回*this。

（5）进一步重载赋值操作符
为提高处理效率，最简单的方法就是重载赋值操作符，使之能够直接使用常规字符串，这样就不用创建和删除临时对象了。下面是一种可能的实现：

String & String::operator=(const char * s)//const String & st -> const char * s{    delete []str;    len = std::strlen(s);    str = new char [len+1];    std:strcpy(str,s);    return *this;}

一般来说，必须释放str指向的内存，并为新字符串分配足够的内存。

4.有关返回对象的说明
当成员函数或独立的函数返回对象时，有几种方式可供选择。可以返回指向对象的引用，指向对象的const引用或const对象。
注意：如果方法或函数要返回局部对象，则应返回对象，而不是指向对象的引用。在这种情况下，将使用复制构造函数来生成返回的对象。如果方法或函数要返回一个没有公有复制构造函数的类（如ostream）的对象，它必须返回一个指向这种对象的引用。最后，有些方法和函数（如重载赋值操作符）可以返回对象，也可以返回引用，在这种情况下，应首选引用，因为其效率更高。
main.pp:

#include <iostream>#include "String.h"const int Arsize = 10;const int MaxLen = 81;int main(){    using std::cout;    using std::cin;    using std::endl;    String name;    cout<<"Hi what's your name?\n";    cin>>name;    cout<<name<<", please enter up to"<<Arsize<<" short sayings <empty line to quite>:\n";    String sayings[Arsize];    char temp[MaxLen];    int i;    for(i = 0;i <Arsize;i++)    {        cout<<i + 1<<": ";        cin.get(temp,MaxLen);        while(cin && cin.get() != '\n')            continue;        if(!cin || temp[0] == '\0')            break;        else            sayings[i] = temp;    }    int total = i;    cout<<"Here are your asyings:\n";    for(i = 0;i < total;i++)        cout<<sayings[i][0]<<": "<<sayings[i]<<endl;    int shortest = 0;    int first = 0;    for(i = 1;i < total;i++)    {        if(sayings[i].length() < sayings[shortest].length())            shortest = i;        if (sayings[i] < sayings[first])            first = i;    }    cout<<"Shortest saying:\n"<<sayings[shortest]<<endl;    cout<<"First salphabetically:\n"<<sayings[first]<<endl;    cout<<"This program used "<<String::HowMany()<<" String objects. Bye.\n";    return 0;}

指针和对象小结
使用对象指针时，需要注意几点

声明指向类对象的指针：
String * pString;

将指针初始化为已有对象：
String * first = &saying[0];

使用new和默认的类构造函数对指针初始化：
String *pString = new String;

使用new和String (const cahr*)类构造函数对指针进行初始化：
String *pString = new String (“hnust”);

使用new和String(const String &)类构造函数对指针进行初始化：
String *favorite = new String (sayings[0]);

使用->操作符通过指针访问类方法：
if (sayings[i].length() < shortest->length());

使用*解除引用操作符从指针获得对象：
if ( sayings[i] < *first )