C++博客-zhuxin-文章分类-C/C++

malloc、calloc、realloc的区别

zhuxin — Sat, 03 Nov 2012 10:36:00 GMT

一内存分配方式：
      1 静态存储区：内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量、static变量。
      2 栈：在函数执行时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高。但是分配的内存容量有限。
      3 堆：程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责何时用free或delete释放内存。动态内存的生存期由用户决定，使用非常灵活，但是问题也最多。
二内存分配相关函数：
      alloca：是向栈申请内存，因此无需释放。
      malloc：分配的内存是位于堆中的，但是没有初始化内存的内容。因此基本上malloc之后，调用函数memset来初始化这部分的内存空间。
      calloc：则将内存初始化为0。
      free：释放申请的内存。
      realloc：对malloc申请的内存进行大小的调整。
      malloc、realloc、calloc三个函数的声明：
      void* malloc(unsigned size);
      void* realloc(void* ptr, unsigned newsize);
      void* calloc(size_t numElements, size_t sizeOfElement);
三区别：
      (1)函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题。
      (2)函数calloc() 会将所分配的内存空间中的每一位都初始化为零,也就是说,如果你是为字符类型或整数类型的元素分配内存,那么这些元素将保证会被初始化为0;如果你是为指针类型的元素分配内存,那么这些元素通常会被初始化为空指针;如果你为实型数据分配内存,则这些元素会被初始化为浮点型的零。
      (3)函数malloc向系统申请分配指定size个字节的内存空间.返回类型是 void*类型.void*表示未确定类型的指针.C,C++规定，void* 类型可以强制转换为任何其它类型的指针。
      (4)realloc可以对给定的指针所指的空间进行扩大或者缩小，无论是扩张或是缩小，原有内存的中内容将保持不变.当然，对于缩小，则被缩小的那一部分的内容会丢失.realloc并不保证调整后的内存空间和原来的内存空间保持同一内存地址.相反，realloc返回的指针很可能指向一个新的地址。
      (5)realloc是从堆上分配内存的.当扩大一块内存空间时，realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平；如果数据后面的字节不够，问题就出来了，那么就使用堆上第一个有足够大小的自由块，现存的数据然后就被拷贝至新的位置，而老块则放回到堆上.这句话传递的一个重要的信息就是数据可能被移动。

zhuxin 2012-11-03 18:36 发表评论

C++模板特化与偏特化

zhuxin — Fri, 26 Oct 2012 08:39:00 GMT

      C++中的模板分为类模板和函数模板。
      (1) 类模板
      定义一个栈的类模板,它可以用来容纳不同的数据类型：
      template ＜class T＞
      class stack
      {
      private:
            list* top;
      public:
           stack();
           stack(const stack&);
           ~stack();
           void push(T&);
           T& pop();
           //…
       };
      上述定义中，template告诉编译器这是一个模板，尖括号中的＜class T ＞指明模板的参数，可以有一个或多个，具体实现时由用户指定，其中template ＜class T ＞中的关键字class可以用关键字typename来代替。
      类模板的使用除了要在声明时指明模板参数外，其余均与普通的类相同，例如：
      stack＜int＞ int_stack;
      stack＜char＞ ch_stack;
      stack＜string＞ str_stack;
      int_stack.push(10);
      ch_stack.push(‘z’);
      str_stack.push(“c++”);

      (2)函数模板
      假设现在要定义一个max函数来返回同一类型(这种类型是允许比较的)两个值的最大者.
      template＜class T＞
      T mymax(const T＆ t1,const T＆ t2)
      {
            return t1 ＜ t2 ? t2 : t1;
      }
      template ＜class T＞的意义与类模板定义中相同。
      模板函数的使用与普通非模板函数使用相同，因为模板函数的参数可以从其传入参数中解析出来。例如：
      int highest = mymax(5,10);
      char c = mymax(‘a’, ’z’);
      mymax(5,10)解析出模板函数参数为int, mymax(‘a’, ’z’)解析出模板函数的参数为char。

      3.模板的特化
      (1)类模板特化
      有时为了需要,针对特定的类型,需要对模板进行特化,也就是特殊处理.例如,stack类模板针对bool类型,因为实际上bool类型只需要一个二进制位，就可以对其进行存储,使用一个字或者一个字节都是浪费存储空间的.
      template ＜class T＞
      class stack
      {
      };
      template ＜＞
      class stack＜bool＞
      {
              //…//
      };
      上述定义中template ＜＞告诉编译器这是一个特化的模板。
      (2) 函数模板的特化
      看下面的例子
      main()
      {
              int highest = mymax(5,10);
              char c = mymax(‘a’, ’z’);
              const char* p1 = “hello”;
              const char* p2 = “world”;
              const char* p = mymax(p1,p2);
      }
      前面两个mymax都能返回正确的结果.而第三个却不能,因为,此时mymax直接比较两个指针p1 和 p2 而不是其指向的内容.
      针对这种情况,当mymax函数的参数类型为const char* 时,需要特化。
      template ＜class T＞
      T mymax(const T t1, const T t2)
      {
               return t1 ＜ t2 ? t2 : t1;
      }
      template ＜＞
      const char* mymax(const char* t1,const char* t2)
      {
               return (strcmp(t1,t2) ＜ 0) ? t2 : t1;
      }
      现在mymax(p1,p2)能够返回正确的结果了。

      4.模板的偏特化
      模板的偏特化是指需要根据模板的某些但不是全部的参数进行特化——————部分参数做特殊处理
      (1) 类模板的偏特化
      例如c++标准库中的类vector的定义
      template ＜class T, class Allocator＞
      class vector
      {
               // … //
      };
      template ＜class Allocator＞
      class vector＜bool, Allocator＞
      {
              //…//
      };
      这个偏特化的例子中，一个参数被绑定到bool类型，而另一个参数仍未绑定需要由用户指定。
      (2) 函数模板的偏特化
      严格的来说，函数模板并不支持偏特化，但由于可以对函数进行重载，所以可以达到类似于类模板偏特化的效果。
      template ＜class T＞ void f(T);   (a)
      根据重载规则，对（a）进行重载
      template ＜ class T＞ void f(T*);   (b)
      如果将（a）称为基模板，那么（b）称为对基模板（a）的重载，而非对（a）的偏特化。C++的标准委员会仍在对下一个版本中是否允许函数模板的偏特化进行讨论。

      5.模板特化时的匹配规则
      (1) 类模板的匹配规则
      最优化的优于次特化的，即模板参数最精确匹配的具有最高的优先权
      例子：
      template ＜class T＞
      class vector
      {
              //…//
      }; // (a)   普通型
      template ＜class T＞
      class vector＜T*＞
      {
              //…//
      };   // (b) 对指针类型特化
      template ＜＞
      class vector ＜void*＞
      {
              //…//
      };   // (c) 对void*进行特化
      每个类型都可以用作普通型（a）的参数，但只有指针类型才能用作（b）的参数，而只有void*才能作为(c)的参数
      (2) 函数模板的匹配规则
      非模板函数具有最高的优先权。如果不存在匹配的非模板函数的话，那么最匹配的和最特化的函数具有高优先权
      例子：
      template ＜class T＞ void f(T);   // (d)
      template ＜class T＞ void f(int, T, double); // (e)
      template ＜class T＞ void f(T*);   // (f)
      template ＜＞ void f＜int＞ (int) ; // (g)
      void f(double);   // (h)
      bool b;
      int i;
      double d;
      f(b); // 以 T = bool 调用（d）
      f(i,42,d) // 以 T = int 调用（e）
      f(&i) ; // 以 T = int* 调用（f）
      f(d);   //   调用（g）

      总结：
      模板特化/全特化是指给每一个模板参数一个具体的类型，以具体实现这个模板，而且template后面的尖括号中不带任何内容;
      模板偏特化是指只给部分模板参数一个具体的类型,来实现这个模板。

zhuxin 2012-10-26 16:39 发表评论

C语言运算符优先级

zhuxin — Thu, 25 Oct 2012 09:40:00 GMT

zhuxin 2012-10-25 17:40 发表评论

深入理解虚函数

zhuxin — Thu, 25 Oct 2012 06:05:00 GMT

摘要: /*虚函数表*/ Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.Cod... 阅读全文

zhuxin 2012-10-25 14:05 发表评论

C++对象内存分配

zhuxin — Tue, 23 Oct 2012 03:04:00 GMT

摘要: 一个空类： Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/--> 1#include 2 3using namespace std; 4 5... 阅读全文

zhuxin 2012-10-23 11:04 发表评论