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）把原来的银行系统改成面向对象的形式。