C++笔记 3

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);
                       }   
                   }
              )

1、排序函数
   void order(int* p1, int* p2){
       if(*p1 > *p2){
           int temp = *p1;
           *p1 = *p2;
           *p2 = temp;
       }
   }

void sort (int *p , int len ， int perLen ， void (*pOrder)(void* , void*)){
       char* pt = (char*)p;
       for(int i = 0 ; i < len ; i++){
            for(int j = i ; j < len ; i ++){
                  pOrder(pt+i*perLen , pt+j*perLen);
            }
       }
   }                       
  
   （1）将输入参数int* -> void*  (void* 可以存储任何类型的地址,可以通用 )
   （2）表示数组的第i个元素，事先要知道数组每个元素的大小(参数传入)
         i*perLen => 当不知道指针类型时，表示走一步，应越过的字节数
         p+i*perLen => 表示第i个元素的地址
   （3）具体的数组要有具体的排序方法
        调用函数，当不知道函数名时，可以通过函数指针调用
       
    ==================================================
                     sort.h
    ==================================================                    
    void sort( void * p , int len , int perLen ,
           void (*pOrder)(void * , void * ) );
    ==================================================
                     sort.cc
    ==================================================
    void sort( void * p , int len , int perLen ,
               void (*pOrder)(void * , void * ) ){

char* pt = (char*)p ;
        for( int i = 0 ; i < len ; i++ ){
           for( int j = i ; j < len ; j++ ){
             pOrder(pt+i*perLen,pt+j*perLen ) ;
           }

}
    }                    
    ==================================================
                     main.cc
    ==================================================
    #include <iostream>
    #include "sort.h"
    using namespace std;

void orderInt( void * p1 , void * p2 ){
      int * t1 = (int*)p1 ;
      int * t2 = (int*)p2 ;
      if( *t1 > *t2 ){
        int temp = *t1 ;
        *t1 = *t2 ;
        *t2 = temp ;
      }
    }

struct Person{
      char name[ 40 ] ;
      int age ;
      int id ;
    } ;

void orderByAge( void * p1 , void* p2 ){
      Person * t1 = (Person*)p1 ;
      Person * t2 = (Person*)p2 ;
      if( t1->age > t2->age ){
         Person t = *t1 ;
         *t1 = *t2 ;
         *t2 = t ;
      } 
    }

void orderById( void *p1 , void* p2 ){
      Person* t1 = (Person*)p1 ;
      Person* t2 = (Person*)p2 ;
      if( t1->id > t2->id ){
         Person t = *t1 ;
         *t1 = *t2 ;
         *t2 = t ;
      }
    }

void orderByName( void * p1 , void* p2 ){
       Person* t1 = (Person*)p1 ;
       Person* t2 = (Person*)p2 ;

if( strcmp( t1->name , t2->name ) > 0 ){
          Person t = *t1 ;
          *t1 = *t2 ;
          *t2 = t ; 
       }
    }
    int main(){
       int ia[] = { 3,1,6,3,6,8,3,468,89 };
       sort( ia , 9, sizeof(int), orderInt );

for( int i = 0 ; i < 9 ; i++ ){
          cout<<ia[i] <<" " ;
       }
       cout<<endl;

Person pers[ 3 ] ;
       pers[0].id = 1 ;
       pers[0].age = 29 ;
       strcpy( pers[0].name , "liucy" ) ;

pers[1].id = 2 ;
       pers[1].age = 28 ;
       strcpy( pers[1].name , "huxinzhe" ) ;

pers[2].id = 3 ;
       pers[2].age = 26 ;
       strcpy( pers[2].name , "xuehailu" ) ; 
 
       sort( pers , 3 , sizeof(Person), orderByAge );
       for( int i = 0 ; i < 3 ; i++ ){
          cout<<pers[i].name <<","<<pers[i].age<<",";
          cout<<pers[i].id<<endl ;
       }

sort( pers, 3, sizeof( Person) , orderById ) ;
       for( int i = 0 ; i < 3 ; i++ ){
          cout<<pers[i].name <<","<<pers[i].age<<",";
          cout<<pers[i].id<<endl ;
       }

sort( pers , 3 , sizeof( Person ) , orderByName );
       for( int i = 0 ; i < 3 ; i++ ){
          cout<<pers[i].name <<","<<pers[i].age<<",";
          cout<<pers[i].id <<endl;
        }
  
 
        return 0 ;
      }
                    
   
   
2、面向对象
   封装：对象表示
   继承：更好的代码重用
   多态
  
   对象的组成 ： 属性   成员变量
                 行为   函数
                
   面向过程的表示方法：
       数据与函数分离，关系松散
       封装的作用，把数据和函数封装到一起，保证数据专用
      
  全局函数：在类外面的函数，要使用成员变量，要通过参数传进来
  成员函数：在类内，可直接使用自己类的成员变量
 
  对于类的变量的初始化：
       Person p ;
       strcpy(p.name , "liucy");
       p.age = 23;
       p.speak();
  对成员变量和成员函数的使用都要通过类的对象
 
  public 关键字，表示在其他地方可以使用
  默认是私有的，在main函数中不能使用
 
  成员变量和成员函数依赖于类的对象（实例）
 
  类型是对对象的描述
  对象是类型的实例
 
  对象自己的成员函数访问自己的成员变量 
 
  什么是类？类由什么组成？
  怎么使用类？及类和对象的关系？
  成员变量和成员函数归谁所有？
 
  面向对象的方法写程序
  （1）首先写一个类，描述对象
       用变量表示属性，函数表示行为
  （2）调用函数
       创建一个类的对象，通过对象调用函数

1、类型封装
   类 --> 对象
   描述 ： （1）属性
           （2）行为    ---属性和行为是属于类的
   创建对象。
  
2、构造函数 --- 初始化对象
   （1）构造函数名字必须与类名一样
   （2）构造函数不能写返回类型
  
   构造函数在创建对象时，系统自动调用
  
   构造函数允许重载，按用户要求，适应多种情况
   当类中一个构造函数都没有的时候，系统提供默认无参的构造函数
   但如果在类中定义了一个构造函数，系统就不提供默认的了，所以，建议，在写构造函数时，都要写一个无参的构造函数
  
3、对类的安全的定义
   变量 -> 私有 -> private  保护变量，防止外界随意修改，只能在类的内部使用（只能被自己的成员函数使用）
   函数 -> 公有 -> public
  
   为保证私有变量也能为外界访问，在类内部提供set,get方法
   set方法没有返回值，但要求有参数
   get方法肯定有返回值，没有参数
  
4、定义类的步骤
   （1）写属性的行为
          成员变量   函数
   （2）成员变量--> private
         成员函数 --> public
    (3)特殊函数
       构造函数，建议写2个。一个有参数的，一个无参的
       get,set函数，一个成员变量对应一对get,set函数，是外界访问此变量的唯一途径
            对于setXXX函数，没有返回值，有参数，参数的类型与被赋值的属性类型一致。
            对于getXXX函数，没有参数，有返回值，返回值的类型与输出的属性类型一致。
       类的行为
      
5、封装
   定义类的过程就是封装
  
练习：封装一个account类型
                属性：id , password ,name ,balance
                行为：save , withdraw , query
               
6、把account类拆成多文件结构
   （1）方便快速浏览整个类定义
   （2）使用方便，包含头文件即可
  
   long Account::getId(){...........}
   在函数实现时，函数前把类名加上，确定函数的所有权,避免2个类中有同名的函数，编译出错。
   " :: "称为域访问控制符。
  
7、Person per ;  创建了一个对象，系统调用构造函数。
   Person *p = NULL ; 声明一个类的指针，系统是不会调用构造函数的
  
   Person * p = NULL;
   p = new Person ; 在堆中申请一个类空间
   delete p;
   在堆中的数据没有名字，只能通过指针访问类对象，访问类的成员变量：
   (*p).sayHello();
   p->sayHello();
  
   Person ps[5];声明一个Person类型的数组，会调用5次构造函数
                数组在声明的时候，系统会为其分配空间
                并且在声明数组的时候，没有机会指定构造函数，只会调用无参的构造函数
               
   当一个类定义中没有无参的构造函数，但要声明一个类的数组时，可以声明一个指针数组
   Person *ps[5];  ---声明指针的时候，类对象没有创建，数组中每个元素都是Person类型的指针，达到：
   （1）不用构造函数
   （2）实现使用对象
  
   for(int i = 0 ; i <5 ; i++){
        ps[i] = new Person(i , 20+i);   //用循环初始化每个指针
   }
   for(int i = 0 ; i < 5 ; i++){
        delete ps[i];                   //释放指针指向的空间
        ps[i] = NULL ;
   }
  
8、课堂练习：
   要求：main()函数中不能写代码，在运行程序时，打印“Hello World”
   答案：全局变量的初始化操作在main函数执行之前就已经初始化了。因此，可以写一个全局变量的类，其无参构造函数写输出语句。
         然后声明一个类的全局对象。
        
9、在构造函数中，当成员变量名称和形参名称相同，避免冲突的方法：
   在每个对象内部都有一个名为this的指针，指向自己，使用自己的成员变量 this->name
  
10、析构函数
    当对象的生命周期结束，系统要回收空间，会自动被调用
    申请的所有资源（new char[20]），在析构函数中释放  
    若对象是在main函数中的变量，在main函数结束之后，才会调用析构函数
    若对象是一个函数中的局部变量，在函数返回时，调用析构函数
   
    析构函数调用 ： 对象生命周期结束，系统自动调用析构函数
                    可以把释放资源的代码写在析构函数中
                   
    析构函数的写法：构造函数前加 “~”
                    不能重载，不能有参数
                   
    若不写析构函数，系统会提供默认的析构函数
   
    当类中用到了系统空间：new内存，打开文件
    就需要写析构函数，释放资源

11、作业：（1）利用面向对象的思想实现栈结构，并自己写main函数测试。

（2）把原来的银行系统改成面向对象的形式。