C 语言小结( 自我总结，仅供参考 )_c语言数组的自我小结-CSDN博客

本文链接：https://blog.csdn.net/shanshanpt/article/details/7361538

1./（★）/可以通过指针来改变int a 中 a 的值；因为指针指是对其地址的操作... ...(很重要!!!)

2.（★）函数名和数组名一样都是常量指针 ,只能指向唯一的内存

3.c语言中 static uint8ucState=0类型为占8个bit的无符号整型的静态变量ucState，赋初值为0。

(附加：误区：const 是常量而stastic是静态变量是不一样的；前者修饰的量不能改变；后者是累加)

(附加：在给数组初始化时应当要注意的：例如： int num[100] = { 0 }; 也就是赋值所有的元素为 0；但是

（★）（★）如果是这个样子： int num[100] = { 1 }; 结果是num[0] =1; 其余元素为 0 )（★）（★）（★）

4.（★）
         也就是说只要涉及到要用指针来储存值时先必须分配内存！！
        ！！！

       如果仅仅是声明一个指针*p,然后让他指向一个struct x;即p=&x;此时无需分配内存

5.数组之间的赋值需要用到strcpy()函数，但是一旦转化为指针，就可以直接是p1=p2;

6.char **和const char **事不一样的，前者指向char *，后者指向const char *
原因:例如:const float * 其实是只想一个具有const限定的float的指针

7./####################################################################/
/####################################################################/
/####################################################################/
/@@@@@@@/其实我们平时的声明就是!!!申请内存!!! 例如int i;即申请了一个内存为sizeof(int)大小的内存的房间，房间名字叫 i

!!!!!!
然后赋值就是给房间住进客官!!!!!!(即赋值是对房间名进行操作,即变量名!!)

8./@@@@@@@/inti=20; int* p; p=&i;
指针的意义:名称为 i 的房间里住着20，p相当于服务员,一旦申请int* p后（相当于聘请好这个服务员）也必须申请了一处内存（即服务员

站在吧台）我现在要找 20 ，怎么办？去吧台找服务员，服务员指着 i 房间说他在那里，然后我就找到了，所以此处的服务员就是一个指

针!!!!!!!!!!!! 他知道 20 的地址，即储存的是 20 的地址，所以我才能找到20 这个人!!!
请注意:::::int* p 中 int* 是一个整体!!!! 是声明指针的!符号! p才是指针变量!!!所以 p 的值是 &20（即20 的地址（房间号））

；所以要读取20 就必须要读 *p !!!!!!

9./@@@@@@@/ 可以通过指针改变原房间中的值也就相当于服务员送走 20后；又迎来 15 客人!!!!!
即: int i=20; int *p;p=&i;(p是指向i的指针) *p=15; printf("%d",i);
此时输出的值是 15 而不是 20 ！！！！！（root:可以通过指针改变原房间中的值）
/####################################################################/
/####################################################################/
/####################################################################/

10.注意细节: int *p;
int a[]={1,2,3,4,5,6};

要把 a[] 赋值给p ，直接是p=a即可，因为a是首地址!!!

/####################################################################/
/####################################################################/

11.请注意数组名与指针的区别: 数组名只不过是一个const 指针（数组名只是指向首地址!!!如果要取得后面的数就只能是相对于首地址的

偏移量!!!而不能是指针的向后移动!!! 因为他是const指针，而指针变量p可以这样），即是指针常量!!! 而指针本身的意义是指针变

量!!!!!!!!!! 所以又有一种情况是指针能做到而数组名做不到的:
int *p;
int a[]={1,2,3,4,5,6};
p=a;
int i;
for(i=0;i<6;i++)
{
printf("%d",p);
p++;
}

偏移量: 例如 *(p+3); *(a+3); a[3]; 三者都是等价的 ^_^

/####################################################################/
/####################################################################/

12.指向指针的指针（即二阶指针）:
int **p;
int a=10;

我们可以知道 p 是储存地址的地址的变量;所以必有 *p=&a;而p是储存&a(也就是*p) 的地址的；所以如果调用出 10 就必须是printf

(**p); 而printf(*p)其实是输出 &a的地址 ......

// 好好理解二阶指针!!!
#include <stdio.h>

void main()
{
int a=10;
int*point;     //一维指针储存 10 的地址
int**ppoint;   //二维指针储存一维指针的地址
   point=&a;
ppoint=&point;  //此处千万不能是 ppoint=&(&a);之类; 因为此处的 &a已经是常量了；不能对常量取地址；而point是变量；

所以可以...
printf("%d\n",*point);
printf("%d\n",**ppoint);
}

void find2(char array[], char search, char **ppa)
    {
           int i;
           for (i=0; *(array + i) != 0; i++)
           {
                   if(*(array + i) == search)
                   {
                      *ppa = array + i;
                      break;
                   }
                  else if(*(array + i) == 0)
                   {
                     *ppa = 0;
                      break;
                   }
           }
    }
ppa指向指针p 的地址。

对*ppa的修改就是对p值的修改。

13.函数指针和指针函数:

函数指针: 例如：void (*fun)(int )

（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）
void MyFun(int x) //声明
{}

void (*fun)(int ); //声明

void main()
{
fun=&MyFun; //把函数地址给函数指针

fun=MyFun; //这是什么？哈哈；也是把函数地址给函数指针

   MyFun(10);     //输出结果

   (*fun)(10);    //可以这样

fun(10); //还可以这样

(*MyFun)(10); //竟然还可以这样

以上说明了什么？》》》》》函数名就是指针（★）

MyFun 的函数名与FunP函数指针都是一样的，即都是函数指针。
MyFun 函数名是一个函数指针常量，而 FunP 是一个函数数指针变量，这是它
们的关系。

}

（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

指针函数: 例如：char *fun(int x) 必须有返回值,而且类型是char * 型

14.
(1)为了防止头文件被重复引用，应当用 ifndef/define/endif 结构产生预
处理块。（★）

    (2)用#include<filename.h>格式来引用标准库的头文件（编译器将从
   标准库目录开始搜索）。
    用 #include“filename.h” 格式来引用非标准库的头文件（编译器将
   从用户的工作目录开始搜索,如果工作目录没有找到，在返回标准库开始搜索）。

15.
/..............#ifndef..#define...#endif............................................./

   #ifndef GRAPHICS_H     // 防止graphics.h 被重复引用（★）（★）（★）
   #define GRAPHICS_H                                   （★）（★）（★）

   #include<math.h>       // 引用标准库的头文件
   …
   #include“myheader.h” // 引用非标准库的头文件
   …
   voidFunction1(…);     // 全局函数声明
   …
   classBox               // 类结构声明
   {
   …
   };
   #endif
  以上是一个头文件块；是用ifndef/define/endif 结构产生预处理块（所有声明在一起是一个
   整体）；

   然后我要生成这些函数或者类；必须在 graphics.cpp中单独写入；
   例如：

   #include"graphics.h" //声明包含在此头文件中

   void Function1()
   {
     printf("hello world");
   }
   class Box //类结构声明
   {
     public:
           ....
     private:
           ....
     protected:
           ....
   };

   现在我要应用此头文件：
   #include "graphics.cpp"//声明包含在此头文件中
   void main()
{
    .....
}

/............#ifndef..#define...#endif..................................................../
16.头文件的作用

（1 ）通过头文件来调用库功能。在很多场合，源代码不便（或不准）向用户公布，只要
      向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功
      能，而不必关心接口怎么实现的。编译器会从库中提取相应的代码。

（2 ）头文件能加强类型安全检查。如果某个接口被实现或被使用时，其方式与头文件中
     的声明不一致，编译器就会指出错误，这一简单的规则能大大减轻程序员调试、改错的
     负担。

17.代码格式(注意空格的添加和 {} 的随时添加 !!!)

（a）为风格良好的代码行（b ）为风格不良的代码行。

int width; //宽度 int width, height, depth; // 宽度高度深度

int height; // 高度

int depth; // 深度

x = a +b; X ＝ a + b; y = c +d; z = e + f;

y = c + d;

z = e + f;

if (width <height) if (width < height) dosomething();

{

dosomething();

}

for (initialization; condition;update) for (initialization;condition; update)

{ dosomething();

dosomething(); other();

}

// 空行

other();

   if 、for 、while等关键字之后应留一个空格再跟左括号 ‘（’，以突出关键字。

‘，’之后要留空格，如 Function(x, y, z) 。如果‘;’不是一行的结束
   符号，其后要留空格，如 for(initialization; condition; update)。

  赋值操作符、比较操作符、算术操作符、逻辑操作符、位域操作符，如“=”、“+= ” “>=”、   “<=”、“+ ”、“* ”、“% ”

、“&&”、“||”、“<<”, “^    ”等二元操作符的前后应当  加空格。

void Func1(int x, int y, intz);          // 良好的风格

void Func1 (int x,int y,intz); // 不良的风格

if (year >=2000) // 良好的风格

if(year>=2000) // 不良的风格

if ((a>=b)&&(c<=d)) // 良好的风格

if(a>=b&&c<=d) // 不良的风格

for (i=0; i<10;i++) // 良好的风格

for(i=0;i<10;i++) // 不良的风格

for (i = 0; I < 10; i++) // 过多的空格

x = a < b ? a :b; // 良好的风格

x=a<b?a:b; // 不好的风格

int *x =&y; // 良好的风格

int * x = &y; // 不良的风格

array[5] =0; // 不要写成 array [ 5 ] = 0;

a.Function(); // 不要写成 a . Function();

b->Function(); // 不要写成 b -> Function();

18. 命名规则

匈牙利命名规则的主要思想：

是“在变量和函数名中加入前缀以增进人们对程序的理解”。例如所有的字符变量均以

ch为前缀，若是指针变量则追加前缀p。如果一个变量由ppch 开头，则表明它是指向字

符指针的指针。

“匈牙利”法最大的缺点是烦琐，例如

int i, j, k;

float x, y, z;

倘若采用“匈牙利”命名规则，则应当写成

int iI, iJ, ik; // 前缀 i 表示 int 类型

float fX, fY, fZ; // 前缀 f 表示 float 类型

共性:
(1)
Windows 应用程序的标识符通常采用“大小写”混排的方式，如 AddChild。
而 Unix 应用程序的标识符通常采用“小写加下划线”的方式，如add_child。别把这两混在一起使用!

(2)
尽量避免名字中出现数字编号，如 Value1,Value2等，除非逻辑上的确需要编号。这是为了防止程序员偷懒，不肯为命名动脑筋而导致产生

无意义的名字（因为用数字编号最省事）。

(3)
1>类名和函数名采用大写字母开头的字母组合而成，例如：class TreeNode; voidSetValue();
2>变量和参数采用小写字母开头，组合名的后面字母仍用大写字母例如：inttreeNode; BOOL flag;
3>所有常量都用大写字母和下划线的组合例如：const int MAX; const intMAX_LENGTH;
4>静态变量前都加上s_;然后的命名和变量时一样的 !!!例如：static ints_treeNode;
5>全局变量前都加上g_(global) 例如：intg_treeNode; (一般情况下不用(少用)全局变量)
6>类的数据成员前加上m_(member)以示区别

19.写if 语句与零值比较
(1):BOOL值例如：bool flag;   if(flag)//flag 为真和 if (!flag) //flag 为假
       其它的用法都属于不良风格，例如：
       if (flag == TRUE)   //注意空格
       if (flag == 1)    //注意空格
       if (flag == FALSE) //注意空格
       if (flag ==0)     //注意空格
(2):整形与零值的比较
       if (curentValue == 0)  //注意空格
       if (curentValue != 0)  //注意空格
(3):浮点值与零值的比较
       if ((curentValue > -0.000001)&& (curentValue <0.000001))
       千万不能直接与0.0之类比较； if (curentValue==0.0) //错误
       要转化为：if((curentValue >-EPSINON)&& (curentValue<EPSINON))
       其中 EPSINON 是允许的误差（此处是0.000001）
(4):指针变量与零值的比较
       定义一个指针变量 p
       if (p == NULL) //不要写成 p ==0   //注意空格
       if (p != 0)

       不要写成：
       if (p == 0 )
       if (p != 0)
       if (p)
       if (!p)

(5):重点补充：有时候把 if (p == NULL) 写成 if (NULL ==p)   其实是防止把if (p == NULL)写成
         if (p = NULL) 而导致出错；编译器编译时 if (p = NULL)是不会报错的，但是如果写成
         if (NULL = p) 是会报错的...(值得学习!!!)

(6): 不良风格:
         if (condition) //注意空格
            return x;
         return y;
    改写后：
        if (condition)   //注意空格
        {
           return x;
        }
        else
        {
           return y;
        }
    或者：
        return (condition ? x : y);  //注意空格

20. for 语句
       (1):在多重循环中，如果有可能，将最大循环放在最里面！in fact 为了减少 CPU的跨切循环层        的次数
       (2):如果循环体内存在逻辑条件判断,最好将它移到循环外面：
       例如：
       for (i = 0; i <= N;i++)           if(condition)
       {                                  {
          if(condition)                     for (i = 0; i <= N;i++)
          {                                  {
             DoSomething();                     DoSomething();
          }                                  }
          else                            }
          {                               else
             DoOtherthing();              {
          }                                  for (i = 0; i <=0; i++)
       }                                     {
                                                    DoOtherthing();
                                              }
                                           }

      如果 N 不大；那么两个执行效率差不多,可以用左边的；如果 N 很大那就用右边的
      (3):最好采用半开半闭的方法
          将上面语句改成：
          for (i = 0; i < N+1; i++)
          {
               ... ...
          }

21. switch语句：结尾的 default 一定要加上；以防别人误以为你忘记 default 的处理

22.
   函数方面:
   (1).书写要完整：例如： voidTreeNode(int x, int y);
                         void TreeNode(int , int );  //不良写法

                         int value(void);
                         intvalue();       //不良写法

  (2).对于指针作为参数的处理，如果只做输入用，最好在前面加上 const ；避免被无意修改！！！

      例如： char *Strcpy(char *strCopyTo, const char *strCopyFrom);

(3).如果输入参数以值传递的方式传递对象，则宜改用“const &“方式来传递，这样可以省去临时对
象的构造和析构过程，从而提高效率。（★）（★）（★）（不懂！！！！！！）

   (4).尽量不要使用类型和数目不确定的参数。C标准库函数 printf 是采用不确定参数的典型代表，
      其原型为：int printf(const chat *format[, argument]…);这种风格的函数在编译时丧失了严
      格的类型安全检查。（★）（★）（★）（不懂！！！！！！）

(5).有时候函数原本不需要返回值，但为了增加灵活性如支持链式表达，可以附加返回值。

例如字符串拷贝函数strcpy 的原型：

char *Strcpy(char *strDest，const char*strSrc); //格式

strcpy 函数将strSrc 拷贝至输出参数strDest 中，同时函数的返回值又是 strDest 。这样做
并非多此一举，可以获得如下灵活性：

char str[20];

      int length = strlen( strcpy(str, “Hello World”)); //经典

   (6).关于函数的 return 语句（★）（★）（★）

      1> return 语句不可以返回指向栈内存的指针或者引用，因为该内存在函数结束时自动销毁
         例如： char *Fun(void)
                 {
                     char str[] = "hello word";  //str 内存位于栈上
                     ...
                     returnstr;                 //错误
                 }

     2> 要尽量提高函数的执行效率
        例如：
                return String(s1 + s2); 和 temp= String(s1 + s2); return temp;

                两者的执行效率是不同的！！前者更好！！前者是创建一个临时的对象并返回它。

                对于后者：首先，temp 对象被创建，同时完成初始化；然后拷贝构造函数把temp 拷贝

                到保存返回值的外部存储单元中；最后，temp 在函数结束时被销毁（调用析构函数）

                。然而“创建一个临时对象并返回它”的过程是不同的，编译器直接把临时对象创建

                并初始化在外部存储单元中，省去了拷贝和析构的化费，提高了效率。

                类似的我们要写：return (x + y); 而不是：temp = x + y; returntemp;

     3>（★）

        程序一般分为 Debug 和 Release 版本，Debug 版本用于内部测试；Release版本用于发行给用
        户。断言( assert ) 的使用时很重要的！！！一般在函数的入口处最好用断言来判断参数的可

        行性。而且 assert 只在 Debug 起作用，是一种宏结构，不是一种函数，是为了避免对我们的

        函数主题产生不必要的影响。assert 的作用是：只要其条件不满足，就会终止程序的运行！！

        例如：
            char *Copy(char *copyTo, const char *copyFrom)
            {
                assert((CopyTo != NULL) &&(CopyFrom != NULL)); // 使用断言

                byte *to=(byte*)copyTo;     //防止改变地址

                byte *from=(byte *)copyFrom; //防止改变地址

                while(*to++ ==*from++);

                return copyTo
            }

      4>（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）
        （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

引用与指针的比较：( 经典 )

引用：n是m的一个引用,m是被引用物；int m ; int &n = m;//好好看看它的形式哦，( ⊙o⊙
)哇，怎么会是这样啊，？这样也行？O(∩_∩)O~；例如一个人叫 m;现在他有一个绰号叫 n ;我们叫 n

;其实也就是在叫 m ；其实 n 就是 m；m 就是n;是同一个人；所以对 n的处理也就是对 m 的处理 ! ! ! ! ! ! （真的要

注意哦对n的处理就是对 m 的处理）

         注意点：(1).引用在被创建的同时必须被初始化（必须的哦）

                 (2).一旦被初始化，就不能改变引用的关系咯

                 例如：int iI =5;    //注意空格命名法则( 匈牙利 )

                       int iJ = 10;

                       int &iK = iI;  //引用参数的定义以及初始化

                       iK =iJ;       //此时 iK 的值改变咯（知道 iK 其实就是 iI ）
                                       //所以此时就是相当于 iI 改变了
                       printf("%d\n", iK); ----> 10

printf("%d\n", iI); ----> 10

printf("%d\n", iJ); ---->10

        引用传递参数的小例子：
                       void Add(int &x) //引用传递的处理像是指针的处理
                       {
                           x += 1;
                       }

                       void main()
                       {
                           int x;

                           Add(x);   //引用传递的传入像是值传递

printf("%d\n", x);
}

       （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）
       （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

23. (深入研究内存问题 )

   欢迎进入内存这片雷区。伟大的 Bill Gates 曾经失言：

640Kought to be enough for everybody

— Bill Gates

   23-1.内存分配的方式：
                 (1).从静态储存区域分配：内存在程序编译时就已经分配好了，这块内存在程序整个
                     运行期间都是存在的。例如：全局变量；static 变量

                 (2).在栈上创建：在执行结束时被自动释放；
                     例如之前的一段程序：

                     char *String(void)
                     {
                         char str[]="hello world"; // 在栈上创建的

                         ... ...

returnstr; // 错误错误错误错误错误错误错误
} //内存在程序结束时被自动释放

(3).在堆上创建：也就是所谓的动态分配(malloc 或者 new 申请内存单元)；程序员

                     自己决定何时释放( free 或 delete )
   23-2.常见的错误：
                 (1).内存未分配成功却使用了它，解决方法：在使用前检查指针是否为 NULL；

                     如果指针 p 是参数；那么可以用断言 assert(p != NULL) 来判断;

                     如果用 malloc 和 new 申请内存，必须用if (p == NULL) or if (p != NULL)

                     来防止出现错误！

                 (2).分配成功；但是未初始化就使用了它

                 (3).操作超过内存边界

                 (4).请注意：自己经常犯的错误：在动态分配时要时刻牢记的不仅是申请内存；更重
                     要的是释放内存！！！规则：malloc 和 free次数必须相同；new 和delete次
                     数必须相同；

                 (5).释放了内存却还在使用它：

                     典例1：栈指针或者栈引用的返回问题 : 在程序执行完后，内存被自动释放；所

                             以是不可以将栈内存的指针或引用返回的! ! ! ! !!

                     典例2：动态分配后，用free和new 释放了内存；但是指针没有设置为 NULL ；
                             导致指针成为野指针

  【规则1】不要忘记为数组和动态内存赋初值。防止将未被初始化的内存作为右值使用。

   【规则2】避免数组或指针的下标越界，特别要当心发生“多 1”或者“少 1 ” 操作。

  【规则3】动态内存的申请与释放必须配对，防止内存泄漏。

【规则4】用free 或 delete 释放了内存之后，立即将指针设置为NULL，防止产生“野指针”。

23-3.
     指针与数组对比：( 宏观上 )（★）（★）（★）（★）（★）（★）（★）（★）（★）

               数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。数组名对应着（而

               不是指向）一块内存，其地址与容量在生命期内保持不变，只有数组的内容可以改变(此
               句话说明或者照应了我以前的说法：数组名实际上就是一个 const 指针，特点是：指向
               唯一内存；但是内存中的值可以改变；函数名本质上也是指针；具体的请看以前的...

O(∩_∩)O~)。指针可以随时指向任意类型的内存块，它的特征是“可变”，所以我们

常用指针来操作动态内存。指针远比数组灵活，但也更危险。

    例如：    char str[] = "hello"; //在栈内存中的分配

               char *p ="world";    //实际上是位于静态存储区相当于指针 p 指向的是const
                                      //即：const char *p；
               str[0] = 'X';

p[0] ='X'; //由以上可知此句是错误的；const 是不能改变的额

puts( str );

puts( p );

23-4.计算内存容量：
           （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

      （1）int str[100]; 用sizeof()；来计算，输出的是 100 ；现在有一个指针p指向数组str；

计算 sizeof( p ); 输出来的结果是 4 ( 很诧异吧，O(∩_∩)O哈哈~ );

实际上sizeof计算的是 sizeof( char * ) == 4；C 和 Cpp都是不能知道指针所指的内存容量的

除非在分配内存的时候记住它；所以sizeof( 指针) == 4 ; 所以计算内存不能用指针计算！！！

      （2）一个典例：

                   int TreeNode( char str[100] ) 或者   void TreeNode( char str[100])
                   {                                    {
                       return(sizeof(str));                 printf("%d\n",sizeof(str));
                   }                                    }

                   以上两种情况输出的结果都是 4；哇塞，不会吧；会的；因为此处的数组已经退化
                   为指针咯

      （3）注意：例如： char str[]="hello"; printf("%d\n", sizeof(str));
                 请问输出的结果是多少呢？   对了是 6 ；请不要把 '\0'不当人！！！我靠！！！

      （4）还要注意：sizeof() 是计算内存大小的；而 strlen() 是计算实际字符串大小的哦

23-5. 指针参数如何传递的？

编译器在编译时总是要给每个参数制作一个副本；指针参数 p 的副本是 _p ；执行函数时；副本

_p 的改变就是指针 P 的改变；

       典例：
                 void GetMemory(char *p, int num)
                 {
                      p = (char *)malloc(sizeof(char) *num)
                 }

                 void main()
                 {
                      char *str = NULL;

GetMemory(str, 100);

assert(str != NULL);

strcpy(str, "hello,world");

puts(str);

                      free(str);   //重要重要重要重要重要重要重要重要重要重要重要
                 }
      貌似这个程序非常正确；其实是从根本上错了；str 根本就没有分配到内存；不信就“断言”吧；

      其实想想也是很简单的；不就是相当于要为   str 分配内存吗？刚开始str中是NULL；现在我要

      改变它就是了；那么不就可以通过指向 str 的指针来改变吗？所以不就可以定义一个指向指针的

      指针来处理吗？
     （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）
      简单一句话-：如果参数是指针；请不要指望让它去申请内存；

      总之如果要用函数来实现给字符串分配内存；请不要传递实参 str 即不要写成形参是指针 *p

      形式；不要指望它；要找就找 &str 和 **p 他们可以做到为你分配内存！！！

     void GetMemory(char **p, int num )
     {
        *p = (char *)malloc(sizeof(char) * num);
     }


     void main()
     {
        char *str = NULL;

GetMemory(&str, 10);

assert(str != NULL);

strcpy(str, "hello");

puts(str);

        free(str);//重要重要重要重要重要重要重要重要重要重要重要

        str = NULL; //好习惯

     }

    另类形式：

     char *GetMemory(int num)
     {
          p = (char *)malloc(sizeof(char) * num);

          returnp;
     }

     void main()
     {
        char *str = NULL;

str = GetMemory(str, 10);

assert(str != NULL);

strcpy(str, "hello");

puts(str);

free(str);//重要重要重要重要重要重要重要重要重要重要重要

str = NULL; //好习惯
}

（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

    这里还强调 return 函数的问题；；；

    例如：    char*GetChar()
              {
                  char str[] = "hello"; //此处是栈内存；程序结束时自动消亡

...

return str; //错误错误错误错误错误错误错误错误错误错误错误错误错误错误
}

              void main()
              {
                  char *str;

str = GetChar(); //得到的是乱码

puts(str);
}

23-6.
      探讨 free 和 delete 把指针怎么了？？？

      O(∩_∩)O哈！它们只不过把指针的内存给释放掉咯；但是并没有把指针本身给干掉（（★））

所以这个指针本身还是存在的；发现指针 p 被 free 以后其地址仍然不变（非NULL），只是

该地址对应的内存是垃圾，p 成了“野指针”。如果此时不把 p 设置为 NULL ，会让人误

      以为 p 是个合法的指针。进而导致错误；而且此时如果用 if (p != NULL) or if(p == NULL)

      都是判断不了的！！！所以切记：：：：：free or delete 之后必须要使之指针为NULL

（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

切记：在 free 和 delete 指针之后；必须把指针赋值为 NULL ；防止指针成为 “野指针” ！

（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

23-7.
     切记：动态内存是不会被自动释放的... ...

     只要你的整个的大的 main() 函数还在执行；不管是那个局部的多么少的动态分配都不会自动释放

；必须的是我们自己 free() 或者 delete() 它们；并且要赋值指针为 NULL；防止变为野指针！

（请不要偷懒或者对这个问题不以为然；会出大问题的！！！靠... ... ）

      》》》》》》指针死了，并不代表它的内存回收咯；内存释放咯，也并不代表指针死了（可能变野
                  指针咯）；

      》》总结：释放内存和让指针变为NULL是不可能同时达到目的的；但是我们又是必须要做的

23-8.
       ————》请杜绝野指针

                            ------By pt

      首先我们来看一下什么要的指针叫“ 野指针 ” ；野指针，顾名思义，是没有人需要的指针，

      或者说你人们害怕的指针！请不要把野指针和和 NULL　指针混淆，　NULL指针　可不是野指针

　　　之前的　２３－６.　也提到了野指针，但那时候重点讲的是　要 free (or delete) 内存，现在

     重点讲野指针：

                 野指针的产生：
                             1. 在定义指针的同时没有初始化指针，这时在使用时它就会乱指一气；

所以在定义时要将指针初始化；可以是 NULL 或者指向...

                                    char *p = NULL;
                                或者
                                    char *p = (char *)malloc(100);

                             2.就是之前所说的 free 和 delete 之后没有赋值指针为 NULL;(注意)

                             3.指针操作超过了变量作用的范围

                               例如：
                                 class A

{

public:

void Func(void){ cout << “Func ofclass A” << endl; }

};

void Test(void)

{

A *p;

{

A a;

p =&a; // 注意 a 的生命期

p->Func(); // p 是正常指针

}

p->Func(); // p 是“野指针”

}

23-9.
      free 和 malloc 与 delete 和 new之间的差别

      free 和 malloc 是库函数，但是 delete 和 new 不是库函数；对于一个外部的对象而言，它在创

      建时要执行构造函数，在消亡时要执行析构函数；但是free 和 malloc 是库函数是库函数，它

      们不在编译器的控制范围之内，不能把执行构造函数和析构函数的任务强加给它们，所以就出现

      了delete 和 new ；理论上讲：delete 和 new 对于内部数据处理时也能代替free 和 malloc，但

      是由于 C 中只能是free 和 malloc，所以free 和 malloc是不能被遗忘的......
23-10.
       内存耗尽怎么办？？？-----》也就是说我在申请动态内存时没有那么大的内存咯，返回了NULL

                                  我该怎么办？？？

       处理 1.
              判断 if ( p = NULL )
                   {
                       return       // 可以用return 语句返回
                   }
       处理 2.
              判断 if ( p = NULL )
                  {
                       cout << “Memory Exhausted”<< endl;

                       exit(1);    // 马上用exit(1)杀死整个应用程序
                  }

附录：关于 exit(1) 和 exit(0)我在这里也要解释一下，其实在正常没有返回值的情况下他们两是完
       全一样的》》》都是杀死应用程序；当时如果有返回值是，exit(0) 表示的是非正常情况下的结
       束，而 exit(1)，或者 exit(2) 等非 0 的数都可以表示正常结束应用程序，一般都用exit(1)；

不过现在对于 32位以上的应用程序来说，基本上是不可能内存耗尽的，因为即使内存耗尽了，”虚存

“可以帮我们忙，自动用硬盘空间来顶替... ...

------》
个人建议最好用exit(1)杀死整个应用程序

23-11.
       new 的使用比malloc要简单多了

       例如：   int *p = (int*)malloc(sizeof(int) * num);

                int *p = new int[num];
       例如：
                #include <iostream>

                using namespace std;

                void main()
               {
         int *pi = new int[10];   //用 new申请内存更方便

         int i ;

         for (i = 0; i < 5; i++)
         {
     cin >> pi[i]>> endl;
     //scanf("%d\n",&pi[i]);
         }

         for (i = 0; i < 5; i++)
         {
     cout << *(pi + i)<< endl;
         }

deletepi; //释放内存挂嘴边
}

     在Ｃ＋＋的类中，对于不同的对象的处理是不同的，所以会有不同的内存的申请方式

     ---》 class Obj
            {... ...};

            Obj *obja = newObj;    //声明一个

            Obj *objb = new Obj(1); //... 外加赋值为1 ；

    （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

     如果用 new 创建对象数组，那么只能使用对象的无参数构造函数。例如

Obj *objects = new Obj[100]; // 创建 100 个动态对象

不能写成：

Obj *objects = new Obj[100](1);// 创建 100个动态对象的同时赋初值 1

在用 delete 释放对象数组时，留意不要丢了符号‘[]’。例如

delete []objects; // 正确的用法

deleteobjects; //错误的用法

     后者相当于 delete objects[0]，漏掉了另外99 个对象。

   （★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）（★）

23-12.
（★）（★）（★）（★）
（★）（★）（★）（★）
#ifndef BOOKSTORE_H //有可能一个源文件中包含了两个以上此头文件，这时防止重复处理相同的头文件
#define BOOKSTORE_H

#endif

条件指示符#ifndef 检查BOOKSTORE_H 在前面是否已经被定义这里 BOOKSTORE_H

是一个预编译器常量习惯上预编译器常量往往被写成大写字母如果BOOKSTORE_H

在前面没有被定义则条件指示符的值为真于是从#ifndef 到#endif 之间的所有语句都被包