The C++ Programming Language 第五章

The C++ Programming Language 第五章 学习笔记
james chen/050220


*********************
5.1指针
*********************

对于类型T,T*就是"到T的指针"，也就是说，一个类型为T*的变量能保存一个类型为T的对象的地址。
char c='a';
char *p=&c;                                               //将c的地址送给char指针p
cout<*p='h';                                                        //间接修改了c,因为p=&c,(*p='h')==(c='h')
cout<

很郁闷的是：到T*、函数的指针,指针数组，玩起来更复杂，哎，go:

一、到T*的指针
　　[到(T类型的指针)的指针],这样理解可能要好一些。

int i=123;
int *p1=&i;
//int** p2=p1;                                           //错，p1只有一个*，故不能赋值
int** p2=&p1;                                       //正确，取p1指针的地址送给p2,相当于int**,刚好与p2匹配
cout<<&i<cout<cout<<&p1<cout<//cout<<*p2<cout<<*(*p2)<                                                                    //也可以写成**p2
**p2=321;                                               //给p3指针所指的指针赋值
cout<cout<<*p1<

延伸学习：
指向T*的指针的指针的指针的......
int a=123;
int *b=&a;
int **c=&b;
int ***d=&c;
int ****e=&d;
int *****f=&e;
*****f=54321;                                       //54321
cout<cout<<*b<cout<<**c<cout<<***d<cout<<****e<cout<<*****f<    //爽啊，原来是这样的，爽够了该继续了。。。

二，指针数组，即数组元素为指针。

int* a[10];                                               //声明一个数组，内含10个元素,为int型指针
for(int i=0;i<10;i++)
a[i]=new int(100+i);                                  //申请int型内存空间，并赋值100+i，再将地址送给a[i]
for(i=0;i<10;i++)
cout<for(i=0;i<10;i++)
cout<<*a[i]<

三，指针与函数

1,指针作为函数的参数
void hehe(int *x)
{*x+=100;}
int a=23;
hehe(&a);
cout<int *b=new int(a);                                      //申请一内存空间，赋值为a
hehe(b);
cout<<*b<

2,指针型函数，即返回一个指针
int *haha(int *x)
{*x+=100;return x;}
int a=1;
int *b=haha(&a);                                          //将返回的地址送给*b
cout<<*b<cout<cout<<*b<cout<<*haha(b)<int c=*haha(b);                                           //将返回地址取值*haha(b),再将值送给int变量
cout<

3.指向函数的指针
就是说将一个函数的首地址赋值给一个函数指针，然后即可用此函数指针操作函数。。

int (*add)(int a);
int add1(int a){return a*10;}
int add2(int a){return a*100;}
int add3(int a){return a*1000;}
add=add1;
int i=2;
int a=add(i);
add=add2;
int b=add(i);
add=add3;
int c=add(i);
cout<
延伸学习：
函数指针数组，主要是觉得每次赋值太过累赘
int add1(int a){return a*10;}
int add2(int a){return a*100;}
int add3(int a){return a*1000;}
int (*add[3])(int a)={add1,add2,add3};         //在声明时就将add1,add2,add3压进去
for(int i=0;i<3;i++)
cout<

注意：函数指针和函数指针数组都只是指针，不是函数，所以千万不要搞个函数体画蛇添足。

//爽啊，这可以俺自己试出来的哦，至少现在俺看过的书上还没有这种玩法，当然，肯定是自己看书太少。

*********************
5.2数组
*********************

数组的初始化
int a[3]={1,2,3};                                       //正确
//int a[3]={1,2,3,4};                                   //错误，数组a只有三个元素
int a[5]={1,2};                                            //正确，相当于int a[5]={1,2,0,0,0};
int a[]={1,2,3,4,5,6};                               //正确
a[]={1,2,3,4};                                        //错误，给一个不存在的数组赋值

5.2.2字符串文字量

字符串文字量是用两个双引号括起来的字符序列，如：
"How are you!!"

一个字符文字量的实际长度要比它所包含的字符个数要多一个，因为它总是由'/0'结尾，如：
szieof("love")==5

字符串文字量的类型是“适当个数的const字符的数组”，所以"love"的类型其实就是const char[5]。
可以用字符串文字量给一个char*赋值，但不能用这个char*去修改字符串文字量，如：
char *a="how are you!!";
cout<//a[0]='a';                                                            //错，给常量赋值，但编译器不会提示

记住：把字符串文字量当成常量。

如果想要修改字符串，就需要将它复制到一个char数组里：
char a[]="how are you!!";
cout<a[3]='a';
cout<

字符串文字量是静态分配的，所以可以让函数返回：
const char* aa()
{return "haha";}
const char *b=aa;
cout<

为了使程序整洁，可以用空白字符将长的字符串分成几个部分，如：
char *p="aaaaaa"
 " bbbbbb"   " ccccc";
cout<

 

*********************
5.3指针与数组
*********************

在c++中，指针与数组密切相关。一个数组的名字即是该数组的首地址，也就可以赋值给同类型的指针。
char x[10]="aaabbbccc";
char* a=x;                                                       //将x的首地址赋值给*a
char* b=&x[3];                                               //将x的第4个元素的地址赋值*b
char* c=&x[6];                                               //将x的第7个元素的地址赋值*c
cout<cout<cout<

5.3.1:在数组里漫游

访问数组可通过下标与指针两种方式：
char a[5]="abcd";
for(int i=0;i<4;i++)                              //i<4亦可换成*b!=0,结束符为0
cout<

char *b=a;
for(i=0;i<4;i++)                                  //i<4亦可换成*b!=0,结束符为0
cout<<*b++<

char *c=a;
while(cout<<*c++<

只有当两个指针指向同一数组元素时，指针之间相减才有意义。如果从一个指针减去另一指针，结果就是这两个指针之间的数组元素个数(一个整数)。指针加或减一个整数，得到的仍是一个指针，如果运算所得指针地址超出数组边界，那这个值是无定义的。

int a[10];
int b[10];
int i=&a[5]-&a[2];  
cout<i=&a[5]-&b[2];
cout<int* p=a+2;                                           //p=a[2];
p=a-2;                                                //出界，*p没定义

郁闷的是，这个出界的指针居然可以使用，怪哉：
cout<<*p<*p=4321;
cout<<*p<

*********************
5.4常量
*********************

常量即不变化的值，一经声明，便可直接使用，但不能修改。
常量声明时必须初始化。

const int a=123;
const int b[]={4,3,2,1}; 
const int c;                                       //出错，未初始化
a=200;                                            //出错，常量不能修改
b[2]=34;                                           //出错，常量不能修改

常量主要用在一些初始化后便不用改变的值，如：
pi圆周率,固定值，不用改变。
一些对象的值。
函数形参，只读不写。
int add100(const int a)
{
a+=100;                                        //出错，不能改变a的值
return a+100;                                 //OK,未改变a的值
}

5.4.1:指针和常量

使用一个指针时涉及到两个对象：指针本身和所指针对象。

const * 将使对象成为常量。                //个人理解为：指针常量
* const 将使指针成为常量。            //个人理解为：常量指针

例：
int i=100;
int o=123;

//const *
int const *p=&i;                            //使对象成为常量
cout<<*p<*p=123;                                       //错，对象为常量，不能赋值
p=&o;                                           //OK，指针不是常量，可以改变地址
cout<<*p<

//* const
int *const p1=&i;                        //常指针
cout<<*p1<*p1=123;                                    //OK,对象非常量，可以改
cout<<*p1<p1=&o;                                        //错，指针为常量，不能改

const int *const p2=&o;                //到const的const指针
*p2=33;                                        //错，p2指向的是常量
p2=&i;                                           //错，p2本身也是常量
cout<<*p2<

*********************
5.5引用
*********************

引用就是对象的另一个名字。引用的主要用途是为了描述函数的参数和返回值，还有运算符重载。

int a=123;
int& b=a;
int c=b;
cout<b=234;
cout<<"a:"<

一个引用的地址在初始化后就不能改变了，它总是指向初始化时所指的那个对象。
所以用作形参会很爽。

注意：不能对一个引用声明时赋值。
int &m=234;                                         //错，常规引用需要一内存单元地址，故不能直接赋值。

但可以用const T&来在声明引用时直接赋值：
const int &m=234;
const T&的实际过程：
1,右值到T类型的隐式转换。
2,将右值放到一个T类型的临时变量中。
3,将此临时变量地址作为初始式的值。
这个临时变量一直存在，直到这个引用的作用域结束。

Bjarne Stroustrup忠告：
.为了提高程序的可读性，通常应该尽可能避免让函数去修改它们的参数。
.如果将“普通”引用参数用于某些函数，那么这些函数的名字就应该给出其引用参数将被修改的强烈提示。

*********************
5.6指向void的指针
*********************

一个指向任何对象类型的指针都可以赋值给类型为void*变量，void*可以赋值给另一个void*,两个void*可以比较相等与否，而且可以显式地将void*转换为另一类型。

int *p=new int(123);
void *a=p;                                           //赋值给void指针
void *b=a;                                           //void指针赋值给另一void指针
cout<cout<cout<cout<<*a<a++;                                                    //出错，不能增量，不知道a的大小
int *t=a;                                               //出错，不能隐式转换
int *t=static_cast(a);                     //OK，可以显式转换回int

void*的最重要的用途是需要向函数传递一个指针，而又不能对对象的类型做任何假设。还有就是从函数返回一个无类型的对象，当然，要使用该对象，必须显示类型转换。

/*
个人理解：将一个对象赋值给void指针后，可以看到两个地址都一样，我想应该可以理解为，void指针是该对象的一个引用，只是类型不明而已，对这个void指针不能使用*，++等取值操作，否则引起错误。
*/

*********************
5.7结构
*********************

数组是相同元素的聚集，而stuct则是任意类型元素的一个聚集。
struct address
{
char *name;
int id;
};

对struct的变量声明和其他类型一样：
address a;
a.name="i love bb!!";
a.id=4321;
对结构类型变量的初始化也可以与数组一样：
address b={"hehe",321};

结构型指针的使用：
address *c=&a;
cout<name<cout<id<cout<<(*c).name<cout<<(*c).id<address d=a;                                               //struct赋值给struct
d=*c;                                                        //struct*赋值给struct

在对struct类型指针的使用时，指针->成员  ==  *指针.成员

*********************
5.8 BS的忠告
*********************

1.避免非平凡的指针技术。
2.当心，不要超出数组的界线去写。
3.尽量使用0而不是NULL。
4.尽量使用vector和valarray而不是内部数组。
5.尽量使用string而不是以0结尾的char数组。
6.尽量少用普通的引用参数。
7.避免void*，除了在某些低级代码里。
8.避免在代码中使用非平凡的文字量("神秘的数")，应该定义和使用各种符号常量。