C++内存管理学习笔记（6）

/****************************************************************/

/*            学习是合作和分享式的！

/* Author：Atlas                    Email：wdzxl198@163.com   

/*  转载请注明本文出处：

*   http://blog.csdn.net/wdzxl198/article/details/9120635

/****************************************************************/

上期内容回顾：

C++内存管理学习笔记（5）

     2.5 资源传递   2.6 共享所有权  2.7 share_ptr

---

3 内存泄漏-Memory leak

3.1 C++中动态内存分配引发问题的解决方案

     假设我们要开发一个String类，它可以方便地处理字符串数据。我们可以在类中声明一个数组，考虑到有时候字符串极长，我们可以把数组大小设为200，但一般的情况下又不需要这么多的空间，这样是浪费了内存。很容易想到可以使用new操作符，但在类中就会出现许多意想不到的问题，本小节就以这么意外的小问题的解决来看内存泄漏这个问题。。现在，我们先来开发一个String类，但它是一个不完善的类。存在很多的问题！如果你能一下子把潜在的全找出来，ok，你是一个技术基础扎实的读者，直接看下一小节，或者也可以陪着笔者和那些找不到问题的读者一起再学习一下吧。

   下面上例子，

/* String.h */
#ifndef STRING_H_
#define STRING_H_

class String
{
private:
    char * str; //存储数据
    int len; //字符串长度
public:
    String(const char * s); //构造函数
    String(); // 默认构造函数
    ~String(); // 析构函数
    friend ostream & operator<<(ostream & os,const String& st);
};
#endif

/*String.cpp*/
#include <iostream>
#include <cstring>
#include "String.h"
using namespace std;
String::String(const char * s)
{
    len = strlen(s);
    str = new char[len + 1];
    strcpy(str, s);
}//拷贝数据
String::String()
{
    len =0;
    str = new char[len+1];
    str[0]='"0';
}
String::~String()
{
    cout<<"这个字符串将被删除："<<str<<'"n';//为了方便观察结果，特留此行代码。
    delete [] str;
}
ostream & operator<<(ostream & os, const String & st)
{
    os<<st.str;
    return os;
}

/*test_right.cpp*/
#include <iostrea>
#include <stdlib.h>
#include "String.h"
using namespace std;
int main()
{
    String temp("String类的不完整实现，用于后续内容讲解");
    cout<<temp<<'"n';
    system("PAUSE");
    return 0;
}

    运行结果（运行环境Dev-cpp）如下图所示，表面看上去程序运行很正确，达到了自己程序运行的目的，但是，不要被表面结果所迷惑！

      这时如果你满足于上面程序的结果，你也就失去了c++中比较意思的一部分知识，请看下面的这个main程序，注意和上面的main加以区别，

#include <iostream>
#include <stdlib.h>
#include "String.h"
using namespace std;

void show_right(const String& a)
{
    cout<<a<<endl;
}
void show_String(const String a) //注意，参数非引用，而是按值传递。
{
    cout<<a<<endl;
}

int main()
{
    String test1("第一个范例。");
    String test2("第二个范例。");
    String test3("第三个范例。");
    String test4("第四个范例。");
    cout<<"下面分别输入三个范例"<<endl;
    cout<<test1<<endl;
    cout<<test2<<endl;
    cout<<test3<<endl;

    String* String1=new String(test1);
    cout<<*String1<<endl;
    delete String1;
    cout<<test1<<endl;

    cout<<"使用正确的函数："<<endl;
    show_right(test2);
    cout<<test2<<endl;
    cout<<"使用错误的函数："<<endl;
    show_String(test2);
    cout<<test2<<endl; //这一段代码出现严重的错误！

    String String2(test3);
    cout<<"String2: "<<String2<<endl;

    String String3;
    String3=test4;
    cout<<"String3: "<<String3<<endl;
    cout<<"下面，程序结束，析构函数将被调用。"<<endl;

    return 0;
}

      运行结果(环境Dev-cpp)：程序运行最后崩溃！！！到这里就看出来上面的String类存在问题了吧。（读者可以自己运行一下看看，可以换vc或者vs等等试试）

     为什么会崩溃呢，让我们看一下它的输出结果，其中有乱码、有本来被删除的但是却正常打印的“第二个范例”，以及最后析构删除的崩溃等等问题。

通过查看，原来主要是复制构造函数和赋值操作符的问题，读者可能会有疑问，这两个函数是什么，怎会影响程序呢。接下来笔者慢慢结识。

     首先，什么是复制构造函数和赋值操作符？------>限于篇幅，详细分析请看《c++中复制控制详解（copy control）》

Tip：复制构造函数和赋值操作符

（1）复制构造函数(copy constructor)

         复制构造函数（有时也称为：拷贝构造函数）是一种特殊的构造函数,具有单个形参,该形参(常用const修饰)是对该类类型的引用.当定义一个新对象并用一个同类型的对象对它进行初始化时,将显示使用复制构造函数.当将该类型的对象传递给函数或者从函数返回该类型的对象时,将隐式使用复制构造函数。

       复制构造函数用在：

• 对象创建时使用其他相同类型的对象初始化；

  Person q("Mickey"); // constructor is used to build q.
  Person r(p);        // copy constructor is used to build r.
  Person p = q;       // copy constructor is used to initialize in declaration.
  p = q;              // Assignment operator, no constructor or copy constructor.

• 复制对象作为函数的参数进行值传递时；

  f(p);               // copy constructor initializes formal value parameter.

• 复制对象以值传递的方式从函数返回。

        一般情况下，编译器会给我们自动产生一个拷贝构造函数，这就是“默认拷贝构造函数”，这个构造函数很简单，仅仅使用“老对象”的数据成员的值对“新对象”的数据成员一一进行赋值。使用默认的复制构造函数是叫做浅拷贝。

       相对应与浅拷贝，则有必要有深拷贝（deep copy），对于对象中动态成员，就不能仅仅简单地赋值了，而应该有重新动态分配空间。

       如果对象中没有指针去动态申请内存，使用默认的复制构造函数就可以了，因为，默认的复制构造、默认的赋值操作和默认的析构函数能够完成相应的工作，不需要去重写自己的实现。否则，必须重载复制构造函数，相应的也需要重写赋值操作以及析构函数。

  2.赋值操作符（The Assignment Operator）

        一般而言，如果类需要复制构造函数，则也会需要重载赋值操作符。首先，了解一下重载操作符。重载操作符是一些函数，其名字为operator后跟所定义的操作符符号，因此，可以通过定义名为operator=的函数，进行重载赋值定义。操作符函数有一个返回值和一个形参表。形参表必须具有和该操作数数目相同的形参。赋值是二元运算，所以该操作符有两个形参：第一个形参对应的左操作数，第二个形参对应右操作数。

      赋值和赋值一般在一起使用，可将这两个看作一个单元，如果需要其中一个，几乎也肯定需要另一个。

         ok，现在分析上面的程序问题。

   a)程序中有这样的一段代码，

 

String* String1=new String(test1);
cout<<*String1<<endl;
delete String1;

      假设test1中str指向的地址为2000,而String中str指针同样指向地址2000，我们删除了2000处的数据，而test1对象呢？已经被破坏了。大家从运行结果上可以看到，我们使用cout<<test1时，从结果图上看，显示的是乱码类似于“*”，而在test1的析构函数被调用时，显示是这样：“这个字符串将被删除：”，程序崩溃，这里从结果图上看，可能没有执行到这一步，程序已经奔溃了。

   b)另外一段代码，

 

cout<<"使用错误的函数："<<endl;
show_String(test2);
cout<<test2<<endl;//这一段代码出现严重的错误！

       show_String函数的参数列表void show_String(const String a)是按值传递的，所以，我们相当于执行了这样的代码：函数申请一个临时对象a,然后将a=test2;函数执行完毕后，由于生存周期的缘故，对象a被析构函数删除，这里要注意！从输出结果来看，显示的是“第二个范例。”，看上去是正确的，但是分析程序发现这里有漏洞，程序执行的是默认的复制构造函数，类中使用str指针申请内存的，默认的函数不能动态申请空间，只是将临时对象的str指针指向了test2，即a.str = test2.str，所以这块不能够正确执我们的复制目的。因为此时test2也被破坏了！

     这是就需要我们自己重载构造函数了，即定义自己的复制构造函数，

String::String(const String& a)
{
    len=a.len;
    str=new char(len+1);
    strcpy(str,a.str);
}

      这里执行的是深拷贝。这个函数的功能是这样的：假设对象A中的str指针指向地址2000，内容为“I am a C++ Boy!”。我们执行代码String B=A时，我们先开辟出一块内存，假设为3000。我们用strcpy函数将地址2000的内容拷贝到地址3000中，再将对象B的str指针指向地址3000。这样，就互不干扰了。

     c)还有一段代码

String String3;
String3=test4;

      问题和上面的相似，大家应该猜得到，它同样是执行了浅拷贝，出了同样的毛病。比如，执行了这段代码后，析构函数开始执行。由于这些变量是后进先出的，所以最后的String3变量先被删除：这个字符串将被删除：String：第四个范例。执行正常。最后，删除到test4的时候，问题来了：程序崩溃。原因我不用赘述了。

      那怎么修改这个赋值操作呢，当然是自己定义重载啦，

版本一，

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

    return *this;
} //重载operator=

版本二，

String& String::operator =(const String& a)
{
    if(this != &a)
    {
        String strTemp(a);

        len = a.len;
        char* pTemp = strTemp.str;
        strTemp.str = str;
        str = pTemp;
    }
    return *this;
}

    这个重载函数实现时要考虑填补很多的陷阱！限于篇幅，大概说下，返回值须是String类型的引用，形参为const 修饰的Sting引用类型，程序中要首先判断是否为a=a的情形，最后要返回对*this的引用，至于为什么需要利用一个临时strTemp，是考虑到内存不足是会出现new异常的，将改变Srting对象的有效状态，违背C++异常安全性原则，当然这里可以先new，然后在删除原来对象的指针方式来替换使用临时对象赋值。

    我们根据上面的要求重新修改程序后，执行程序，结果显示为，从图的右侧可以到，这次执行正确了。

3.2 如何对付内存泄漏

        写出那些不会导致任何内存泄漏的代码。很明显，当你的代码中到处充满了new 操作、delete操作和指针运算的话，你将会在某个地方搞晕了头，导致内存泄漏，指针引用错误，以及诸如此类的问题。这和你如何小心地对待内存分配工作其实完全没有关系：代码的复杂性最终总是会超过你能够付出的时间和努力。于是随后产生了一些成功的技巧，它们依赖于将内存分配（allocations）与重新分配（deallocation）工作隐藏在易于管理的类型之后。标准容器（standard containers）是一个优秀的例子。它们不是通过你而是自己为元素管理内存，从而避免了产生糟糕的结果。

    如果不考虑vector和Sting使用来写下面的程序，你大脑很会费劲的…..

#include <vector>
#include <string>
#include <iostream>
#include <algorithm>

using namespace std;

int main() // small program messing around with strings
{
    cout<<"enter some whitespace-seperated words:"<<endl;
    vector<string> v;
    string s;
    while (cin>>s)
        v.push_back(s);
    sort(v.begin(),v.end());
    string cat;
    typedef vector<string>::const_iterator Iter;
    for (Iter p = v.begin(); p!=v.end(); ++p)
    {
        cat += *p+"+";
        std::cout<<cat<<'n';
    }
    return 0;
}

    运行结果：这个程序利用标准库的string和vector来申请和管理内存，方便简单，若是设想使用new和delete来重新写程序，会头疼的。

      注 意，程序中没有出现显式的内存管理，宏，溢出检查，显式的长度限制，以及指针。通过使用函数对象和标准算法（standard algorithm），我可以避免使用指针——例如使用迭代子（iterator），不过对于一个这么小的程序来说有点小题大作了。

这些技巧并不完美，要系统化地使用它们也并不总是那么容易。但是，应用它们产生了惊人的差异，而且通过减少显式的内存分配与重新分配的次数，你甚至可以使余下的例子更加容易被跟踪。 如果你的程序还没有包含将显式内存管理减少到最小限度的库，那么要让你程序完成和正确运行的话，最快的途径也许就是先建立一个这样的库。模板和标准库实现了容器、资源句柄等等

如果你实在不能将内存分配/重新分配的操作隐藏到你需要的对象中时，你可以使用资源句柄（resource handle），以将内存泄漏的可能性降至最低。

      这里有个例子：需要通过一个函数，在空闲内存中建立一个对象并返回它。这时候可能忘记释放这个对象。毕竟，我们不能说，仅仅关注当这个指针要被释放的时候，谁将负责去做。使用资源句柄，这里用了标准库中的auto_ptr，使需要为之负责的地方变得明确了。

#include<memory>
#include<iostream>
using namespace std;

struct S {
    S() { cout << "make an S"<<endl; }
    ~S() { cout << "destroy an S"<<endl; }
    S(const S&) { cout << "copy initialize an S"<<endl; }
    S& operator=(const S&) { cout << "copy assign an S"<<endl; }
};

S* f()
{
    return new S; // 谁该负责释放这个S？
};

auto_ptr<S> g()
{
    return auto_ptr<S>(new S); // 显式传递负责释放这个S
}

void test()
{
    cout << "start main"<<endl;
    S* p = f();
    cout << "after f() before g()"<<endl;
    // S* q = g(); // 将被编译器捕捉
    auto_ptr<S> q = g();
    cout << "exit main"<<endl;
    // *p产生了内存泄漏
    // *q被自动释放
}
int main()
{
    test();
    system("PAUSE");
    return 0;
}

      运行这个程序（dev-cpp），可以看到p产生内存泄漏，而通过auto_ptr智能指针，则内存管理自动化了 ---->为什么？详见《C++内存管理学习笔记（4）》

     综合以上的内容，我们需要考虑更一般的意义上考虑资源，而不仅仅是内存。如果在你的环境中不能系统地应用这些技巧，那么注意使用一个内存泄漏检测器作为开发过程的一部分，或者插入一个垃圾收集器（garbage collector）。

3.3 浅谈C/C++内存泄漏及其检测工具

        对于一个c/c++程序员来说，内存泄漏是一个常见的也是令人头疼的问题。已经有许多技术被研究出来以应对这个问题，比如Smart Pointer，Garbage Collection等。Smart Pointer技术比较成熟，STL中已经包含支持Smart Pointer的class，但是它的使用似乎并不广泛，而且它也不能解决所有的问题；Garbage Collection技术在Java中已经比较成熟，但是在c/c++领域的发展并不顺畅，作为一个c/c++程序员，内存泄漏是你心中永远的痛。不过好在现在有许多工具能够帮助我们验证内存泄漏的存在，找出发生问题的代码。

3.3.1 内存泄漏定义

      一般常说的内存泄漏是指堆内存的泄漏。堆内存是指程序从堆中分配的，大小任意的（内存块的大小可以在程序运行期决定），使用完后必须显示释放的内存。应用程序一般使用malloc，realloc，new等函数从堆中分配到一块内存，使用完后，程序必须负责相应的调用free或delete释放该内存块，否则，这块内存就不能被再次使用，我们就说这块内存泄漏了。

      以下这段小程序演示了堆内存发生泄漏的情形：

void MyFunction(int nSize)
{
    　char* p= new char[nSize];
    　if( !GetStringFrom( p, nSize ) ){
    　MessageBox(“Error”);
    　return;
    　}
    　…//using the string pointed by p;
    　delete p;
}

       当函数GetStringFrom()返回零的时候，指针p指向的内存就不会被释放。这是一种常见的发生内存泄漏的情形。程序在入口处分配内存，在出口处释放内存，但是c函数可以在任何地方退出，所以一旦有某个出口处没有释放应该释放的内存，就会发生内存泄漏。  

       内存泄漏不仅仅包含堆内存的泄漏，还包含系统资源的泄漏(resource leak)，比如核心态HANDLE，GDI Object，SOCKET， Interface等，从根本上说这些由操作系统分配的对象也消耗内存，如果这些对象发生泄漏最终也会导致内存的泄漏。而且，某些对象消耗的是核心态内存，这些对象严重泄漏时会导致整个操作系统不稳定。所以相比之下，系统资源的泄漏比堆内存的泄漏更为严重。

3.3.2 内存泄漏的发生方式

     以发生的方式来分类，内存泄漏可以分为4类：

1. 常发性内存泄漏。发生内存泄漏的代码会被多次执行到，每次被执行的时候都会导致一块内存泄漏。

2. 偶发性内存泄漏。发生内存泄漏的代码只有在某些特定环境或操作过程下才会发生。常发性和偶发性是相对的。对于特定的环境，偶发性的也许就变成了常发性的。所以测试环境和测试方法对检测内存泄漏至关重要。

3. 一次性内存泄漏。发生内存泄漏的代码只会被执行一次，或者由于算法上的缺陷，导致总会有一块仅且一块内存发生泄漏。比如，在类的构造函数中分配内存，在析构函数中却没有释放该内存，但是因为这个类是一个Singleton，所以内存泄漏只会发生一次。另一个例子：

char* g_lpszFileName = NULL;
void SetFileName( const char* lpcszFileName )
{
    if( g_lpszFileName ){
        free( g_lpszFileName );
    }
    g_lpszFileName = strdup( lpcszFileName );
}
/*如果程序在结束的时候没有释放g_lpszFileName指向的字符串，
那么，即使多次调用SetFileName()，总会有一块内存，而且仅有一块内存发生泄漏。*/

4. 隐式内存泄漏。程序在运行过程中不停的分配内存，但是直到结束的时候才释放内存。严格的说这里并没有发生内存泄漏，因为最终程序释放了所有申请的内存。但是对于一个服务器程序，需要运行几天，几周甚至几个月，不及时释放内存也可能导致最终耗尽系统的所有内存。所以，我们称这类内存泄漏为隐式内存泄漏。举一个例子：

class Connection
{
public:
    Connection( SOCKET s);
    ~Connection();
    …
private:
    SOCKET _socket;
    …
};
class ConnectionManager
{
public:
    ConnectionManager(){}
    ~ConnectionManager(){
        list::iterator it;
        for( it = _connlist.begin(); it != _connlist.end(); ++it ){
        delete （*it）;
        }
    _connlist.clear();
　　}
    void OnClientConnected( SOCKET s ){
        Connection* p = new Connection(s);
        _connlist.push_back(p);
    }
    void OnClientDisconnected( Connection* pconn ){
        _connlist.remove( pconn );
        delete pconn;
    }
private:
    list _connlist;
};
/*假设在Client从Server端断开后，Server并没有呼叫OnClientDisconnected()函数，
那么代表那次连接的Connection对象就不会被及时的删除（在Server程序退出的时候，
所有Connection对象会在ConnectionManager的析构函数里被删除）。当不断的有连接建立、
断开时隐式内存泄漏就发生了。*/

        从用户使用程序的角度来看，内存泄漏本身不会产生什么危害，作为一般的用户，根本感觉不到内存泄漏的存在。真正有危害的是内存泄漏的堆积，这会最终消耗尽系统所有的内存。从这个角度来说，一次性内存泄漏并没有什么危害，因为它不会堆积，而隐式内存泄漏危害性则非常大，因为较之于常发性和偶发性内存泄漏它更难被检测到。

---

参考资料详见《 c++内存管理学习纲要》

Edit by Atlas

Time：2013/6/18 14：51