﻿<?xml version="1.0" encoding="utf-8" standalone="yes"?><rss version="2.0" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:trackback="http://madskills.com/public/xml/rss/module/trackback/" xmlns:wfw="http://wellformedweb.org/CommentAPI/" xmlns:slash="http://purl.org/rss/1.0/modules/slash/"><channel><title>C++博客-zhuyuyuseu-随笔分类-C++/C</title><link>http://www.cppblog.com/zhuyuyuseu/category/1748.html</link><description /><language>zh-cn</language><lastBuildDate>Mon, 02 Jun 2008 21:24:40 GMT</lastBuildDate><pubDate>Mon, 02 Jun 2008 21:24:40 GMT</pubDate><ttl>60</ttl><item><title>函数的特性</title><link>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7140.html</link><dc:creator>Gerrard</dc:creator><author>Gerrard</author><pubDate>Sun, 14 May 2006 13:18:00 GMT</pubDate><guid>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7140.html</guid><wfw:comment>http://www.cppblog.com/zhuyuyuseu/comments/7140.html</wfw:comment><comments>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7140.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/zhuyuyuseu/comments/commentRss/7140.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/zhuyuyuseu/services/trackbacks/7140.html</trackback:ping><description><![CDATA[函数的重载：语义和功能相似的函数用相同的名字表示，编译器根据不同的参数为不同的函数产生不同的内部标识符
C++函数调用C函数：extern "C"{ }
!!并不是函数名相同就是重载，全局函数和类成员函数就不是重载，作用域不同
防止隐式类型转换而导致重载函数调用的二义性

成员函数的重载、覆盖和隐藏
重载的特征overload：
（1）具有相同的范围（在同一个类中）
（2）函数名字相同
（3）参数不同
（4）virtual关键字可有可无
覆盖的特性overriding:
派生类覆盖基类的函数：
 （1）范围不同（不在同一个类中）
 （2）函数名字相同
 （3）参数相同
 （4）基类必须带virtual关键字
隐藏规则：
（1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual
关键字，基类的函数将被隐藏（注意别与重载混淆）。
（2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual
关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）。


参数的缺省
只能出现在函数声明中

关键字inline 必须与函数定义体放在一起才能使函数成为内联
定义在类声明之中的成员函数将自动地成为内联函数
（1）如果函数体内的代码比较长，使用内联将导致内存消耗代价较高。
（2）如果函数体内出现循环，那么执行函数体内代码的时间要比函数调用的开销大<img src ="http://www.cppblog.com/zhuyuyuseu/aggbug/7140.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/zhuyuyuseu/" target="_blank">Gerrard</a> 2006-05-14 21:18 <a href="http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7140.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item><item><title>不是用指针的程序员不是合格的程序员!</title><link>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7131.html</link><dc:creator>Gerrard</dc:creator><author>Gerrard</author><pubDate>Sun, 14 May 2006 07:01:00 GMT</pubDate><guid>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7131.html</guid><wfw:comment>http://www.cppblog.com/zhuyuyuseu/comments/7131.html</wfw:comment><comments>http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7131.html#Feedback</comments><slash:comments>0</slash:comments><wfw:commentRss>http://www.cppblog.com/zhuyuyuseu/comments/commentRss/7131.html</wfw:commentRss><trackback:ping>http://www.cppblog.com/zhuyuyuseu/services/trackbacks/7131.html</trackback:ping><description><![CDATA[1)内存的几种分配方式:
   静态存储区:全局变量和静态变量
  栈空间:局部变量,参数
  堆分配(动态)
2)常见的内存处理错误以及策略:
  1 分配未成功就开始使用
   对策:检测指针是否为NULL(判断)
     ex:assert(p!=NULL)//若Ｐ为函数的参数
　　　 if(p!=NULL)/if(p==NULL) //判断分配内存是否有效
　2 内存分配成功但没初始化（赋初值）
　3 内存分配成功但操作越界
　4 忘记释放内存而造成内存泄露
　5 释放了内存却继续使用它
　　原因：过多的对象调用
　　　　　return语句中返回了指向栈空间的指针或其引用，该内存在函数体结束后自动销毁
　　　　　使用free/delete后没有将指针置NULL产生野指针
3)数组和指针的区别
　1　内容的修改：
　　ex1:
          char a[]="hello";  //a为字符数组
          a[0]='X';　　　　//a的内容可以修改
          cout<<a<<endl;　//输出：Xello　
          char*p="hello";  //　P为常量指针；
          p[0]='X';　　　　//*p不能修改
          cout<<p<<endl;　　//程序运行到这里出错
  2 内容的复制与比较
    若想把一个字符数组的内容赋给另一个数组strcpy(b,a);
      比较用strcmp(a,b);
      对指针来说p=a相当于把a的地址给p，若要拷贝b的内容得申请内存空间，容量为strlen(a)+1，再用strcpy
      ex:
      int len=strlen(a);
      char*p=(char*)malloc(sizeof(char)*(len+1));
      strcpy(p,a);
      strcmp(p,a);
     计算内存容量：sizeof()              !sizeof(p)为4:指针变量的字节数
　 ex:
       char a[]="hello";
       sizeof(a);//6
       char*p=a;
       sizeof(p);//4
      void fun(char a[100])
     {
      sizeof(a);//4 因为传参时实际传递的是数组的首地址，数组退化为指针
   }
4)指针参数是如何传递内存的
 1 不能指望用函数参数表中的指针去申请内存
　　　分析：
        void GetMemory(char*p,int num)
            {
              p=(char*)malloc(num*sizeof(char));
            }
           void Test()
          {
            char*str=NULL;
            GetMemory(str,100);
            strcpy(str,"hello");
            cout<<str<<endl;
          }
}
         程序运行出错，str还是NULL.传递参数时在形参Ｐ中产生了str副本，函数结束后p随此而消失但分配的内存为被释放，所以每调用一次就造成一次内存泄露
　2 改变上面的错误的两种方法：
　　　１传递指针的指针：
　　　　　void getmemory(char**p,int num)
              {
                 *p=(char*)malloc(sizeof(char)*num);
              }
              void test()
              {
                 char*str;
                 getmemory(&str,100);
                 strcpy(str,"hello");
                 cout<<str<<endl;
                 free(str);
                 str=null;     
              }
         2 用返回值
　　　　char*getmemory(int num)
            {
             char*p=(char*)malloc(sizeof(char)*num);
             return p;
            }
            void test()
           {
            char*str=NULL;
            str=getmemory(100);
            strcpy(str,"hello");
            cout<<str<<endl;
            free(str);
            str=NULL;
           }
       3 不能用return返回指向栈内存的指针，
　　　　　char*getmemory()
              {
                 char p[]="hello";
                 return p;
               }
              void test()
             {
                 char*str=NULL;
                 str=getmemory();
                 cout<<str<<endl;
                }
         由于Ｐ是局部数组，因此只有函数作用，随函数的调用结束而消失，str指向垃圾内存，野指针
　　4 char*GetMemory()
         {
           char*p="hello";//p是常量指针，在test中是只读的
           return p;
         }
5)free/delete只是把指针所指的内存释放掉，并没有把指针本身消除掉，此时指针不置为NULL，该指针就是野指针，即使用(p==null)也没起到防护作用，该指针指的不是合法的内存区域
　！！指针消亡了并不代表它所指的内存空间被释放了
　！！指针所指的内存空间被释放了并不代表指针会消亡或变为null
6)杜绝野指针：指向垃圾内存的指针
　　形成野指针的原因：
　　　指针变量没有被初始化
　　　在被free/delete后没有将指针置null，让人误认为是合法的指针
　　　指针的操作超过了变量的作用域
7)malloc/free为库函数，不能满足非内部数据类型的对象，不能执行构造函数和析构函数
8)内存耗尽怎么办
　如果在申请内存时找不到足够大的内存块，malloc/new 会返回NULL指针;
对策：
　判断是否为NULL指针，如果为null用return
   用exit(1)
   设置异常处理
尽量用第二种方法来处理
对于３２位以上的应用程序，无论怎样使用malloc和new，几乎不能导致内存耗尽        <img src ="http://www.cppblog.com/zhuyuyuseu/aggbug/7131.html" width = "1" height = "1" /><br><br><div align=right><a style="text-decoration:none;" href="http://www.cppblog.com/zhuyuyuseu/" target="_blank">Gerrard</a> 2006-05-14 15:01 <a href="http://www.cppblog.com/zhuyuyuseu/archive/2006/05/14/7131.html#Feedback" target="_blank" style="text-decoration:none;">发表评论</a></div>]]></description></item></channel></rss>