C++day07 学习笔记

1、数组是自动分配空间，指针要手工分配空间（int *p = new int;）

2、在Unix上，程序出现段错误的时候，系统会生成core 文件，会把出现错误的那一刻的程序镜像保存在此文件中

3、结构的成员变量出现数组：

    struct Account{
          long id ;
          //char name[ 50 ] ;
          //char password[ 10 ] ;
          char * pname ;
          char * ppwd ;
          double balance ;    
    };

   数组长度100-200字节，最好用数组做，这样方便
   数组很大的时候，可以考虑用指针,赋值的时候要注意：
   a.pname = new char[50];
   strcpy(a.pname , "huxinzhe");
  
   在结构声明时，不能给成员变量赋值
   结构声明只是声明了一种数据类型，还没有为这个结构申请空间，赋值的数据没有空间保存

4、危险指针的用法
   使用NULL指针的内容 ---隐蔽性不高，容易发现
   使用没有初始化的指针 --- 会导致无意当中修改其它变量，破坏性很大，避免的办法  int *p = NULL;
   使用已经被delete的指针内容  ---  修改其它变量  避免的办法  delete p ;   p=NULL;
   返回一个局部变量的地址 
   由函数申请空间，由调用者释放

   #include <iostream>
   using namespace std;

   char * readLine(){
        char * line = new char[ 100 ] ;  //在函数中申请了空间，但是没有地方释放
        strcpy( line , "hello world" ) ;
        cout<<"line = " << line << endl;
        return line ;                    //返回变量的指针，若是局部变量，在函数返回的时候，就消失了，若在堆中申请空间，没有释放空间的机会
   }
   int main(){
        char * p = readLine();
        cout<<"return from readLine "<<endl;
        cout<<"p = " << p << endl;
        delete p;                         //释放别人申请的空间，不安全
        return 0 ;
   }

   解决的办法 ： 在函数外部申请一个指针并初始化，作为参数传给函数，这样可以保存数据并返回
                 在参数中传数组的起始地址，和数组长度
   只要是参数传指针，指针在传给函数之前要进行初始化

5、编译的时候不想看到警告信息  g++ -w
  
6、函数指针的声明：
   函数的名字就是这个函数的首地址
   函数指针之间的赋值，也要同类型的
   函数指针是不需要释放的。
  
   函数指针，设计通用算法
  
7、多层指针

   int i = 10;
   int * p = &i;
   int ** pp =&p;
   int**(*ppp) = & pp;
   
   *p = i ;
   *pp = p;
   **pp = i;

   多层指针的使用 ：

   int ia[2][3] = {{11,12,13},
                   {21,22,23}};  //声明并定义一个二维数组
   cout << ia[0] << endl;  //打印的是ia的第一个数组的首地址
   
   int * p = ia[0]; //保存ia第一个数组的首地址
   cout << a[0][2] <<endl;
   cout << p[2] <<endl;  //与上面一行具有相同的效果 。
   
   ia[0]的类型就是int*类型的，指向ia的第一个数组
   ia也是个指针类型，指向那个二维数组 ，是 int**

   二维数组是一个二级指针
   二维数组的每个元素是一级指针

   int （*pp）[3] = ia;      //行指针，指向二维数组的一行，[]中的数字表示每一行的元素个数
   cout << pp[1][1] <<endl;  //通过二级指针去数组元素  pp[1][1] <=> *( *(pp+1) +1 )

   行指针可以描述指向数组的元素个数，以行为单位，加1就是指针指到下一行
   打印数组在内存中地址

   int (*p1)[3] --> p1的类型是int[3]  p1+1，走3个int,一个数组的长度
   int ** p2    --> p2的类型是int*    p2+1,走1个int

8、

   char* names[100]; 声明一个数组，每个元素类型是char*
   chat* names[3] = {"liucy","huxz","tangliang"};  //这样的声明更清晰的说明是char的二维数组
   for(int i = 0 ; i < 3 ; i++){
      cout << names[i] <<endl;             //打印每个元素
   }

9、void*
   任何类型的变量的地址都可以把地址存进来
   通用指针的存储，不能做任何运算，是纯粹的存储地址而用

10、const与指针
   const int *p  常量指针 不能通过指针改变变量的值  const离int近，值不能改
   int* const p  指针常量 指针不能改，指向的对象是固定的，但可以通过指针改变变量的值

11、指针的要求
   指针的声明和基本运算
   数组与指针的关系，结构和指针的关系，字符指针的用法
   堆空间及危险用法

12、引用
    引用就是一个变量的别名  int &iR= i;  //给i起的别名iR
    引用声明的时候必须初始化(与一个变量保持关联关系)，一旦赋值，就不能把别名再给别的变量了
   
    int iL = 100;
    iR = iL; // 相当于把i的值改变了，iR还是i的别名

13、引用的使用
    以引用的形式传参数 fn(int &a)
    在函数内部的操作就是对此实参进行操作
   
    一般情况下  （1）在真的想改变实参的值的时候
                （2）在实参的大小比较大的时候，传引用，这样系统不生成临时变量，减小耗费内存
    的时候传引用。
   
    fn(const int &a) 这样传引用，不会创建临时变量，也不会改变实参的值

14、周末项目
   （1）完善项目 把密码用char数组保存
   （2）写一个函数，对所有类型的数组进行排序
        提示：通过函数指针实现对struct传参数
              void* 指针，存储所有类型指针

              void sort (int perlen , int *p , int len , void (*order)(int * ,int *)){
                   char *p1 = (char*)p;        //char是基本类型里最小的，可以模拟步长
                   for(int i = 0 ; i < len ; i ++{
                          for(int j = 0 ; i < len ; i++){
                               order(p+i*prolen,p+j*prolen);
                          }    
                   }
              )