白话编程--数据篇(3)_指针(2)

前言

        指针内容接续

指针常量和常量指针

        两种常用的指针.首先理解"常变量"

        1>const关键字和常变量

        const是一个修饰变量的关键字,按字面意思constant---常量.

        举例:

                const int LENGTH=10;

                计算机中的值都是按二进制表示,类似于0B01100101

                数字10是个常量.在变量前加上const修饰,表示该变量成为和等号左边完全等价的值

                ------本例中LENGTH和10完全等价,于是LENGTH成为"常变量"

        常变量的概念:用变量表示的常量. 

        const使用规则

                非const数据可以赋给const数据, const数据可以赋给const数据

                const数据不能赋给非const数据

                理解: const属于严格检查,只要const接受的,被定义为"不能更改".

        有人可能会问:常量就是常量,变量就是变量,常变量是什么?又能干什么?

        答:常变量通常用来实现数值抽象.

        举例:       

        写一个循环,求1到10的和

int sumInt(){
    int sum=0;
    for(int i=0;i<10;i++){
        sum+=i;
    }
    return sum;
}
    

        现在需求变了:写一个循环,求1到20的和

int sumInt(){
    int sum=0;
    for(int i=0;i<20;i++){
        sum+=i;
    }
    return sum;
}
    

        如果我们开始定义条件变量的退出条件为LENGTH,那么程序修改起来会更简单一些 

const int LENGTH =20
int sumInt(){
    int sum=0;
    for(int i=0;i

        这时您可能会说这样写不是也挺麻烦,传入循环长度才符合函数的思想吗 

int sumInt(int n){        /*n表示循环长度*/
    int sum=0;
    for(int i=0;i

         是的,您的想法是对的,这才是最好的实现方式. 

         之所以引入常变量,是避免硬编码的一种方式,有时候好用.

         硬编码:函数中非必要的数值常量出现. 

         是函数定义的一种不成文的规定:应避免数值常量出现,尽量以符号常量代替.

        2>指针常量

        概念:指针常量指地址常量.一个不变的地址.

        举例:int a[]={10,20,30};//数组

                int * const p=a;                //a和p是指针常量

        最常见的指针常量就是数组名. 这里的数组名a就是指针常量.理解如下:

                对比其他类型定义 int b=10;  b是变量,10是常量. 

                这里的p是指针变量,a是指针常量.所以:

                 常量和变量的关系始终是  "变量=常量" 常量赋值给变量    //复习常量和变量的关系

           指针常量,又称为指针const,科学的叫法是"指针常变量",沿用书上叫法"指针常量"   

                所以:这里的p和a都被称作指针常量,虽然p严格来讲是指针常变量.         

        指针常量的写法

                指针类型名 + const + 指针变量名 = 指针常量

        指针常量的用法

               1>指针常量不可以指向其他地址.   

                例如:a是&a[0],表示a[0]的地址;但不可以用a表示&a[1],已被固定.

                         同样p只能指向a[0],不可以用p表示其他地址.

                          假设另外定义一个数组 int b[]={40,50,60};

                          p=b;                           //错误写法!

               2>可以用指针常量修改指向地址中的值.

                           *p=40;                  //允许

                            *a=40;                  //允许              

                C++中的"引用类型reference"本质上就是指针常量,好处是节省内存空间.

        3>常量指针

                概念:指针指向的地址内的数据不能改变.

                举例:

                        int b[]={40,50,60};

                        const int *q=b;        //定义常量指针指向地址b

          常量指针的写法

                        const + 指针类型 + 指针变量名 = 指针常量     ----平常指针定义前加上const.

           常量指针的用法

                1>常量指针可以指向其他地址

                2>不可以用常量指针修改其指向地址里的值.

                举例: 

                        将一个整型数组内的数据复制到另一个数组,假设数组内元素个数为n

#include
#include
int * copyIntArray(const int * ar, int n);    /*声明整型数组复制函数*/
int main(void){
	
	int a[]={1,2,3,4,5,6,7,8,9,10};
	int *p=copyIntArray(a,10);
	for(int i=0;i<10;i++){
		printf("%d\n",*p++);
	}
}

int * copyIntArray(const int * ar, int n){    /*复制函数定义*/
	int* p = (int*)malloc(sizeof(int) * n);   /*开辟内存空间*/ 
	for(int i=0;i

                        例2:字符串复制

#include
#include
#include
void copyString(const char * ar,char * newString);	/*声明字符串复制函数*/
int main(void){
	
	char *welcome="hello";
	char nString[6];                                /*分配一个6字符空间给数组*/
	copyString(welcome,nString);
	printf("%s\n",nString);
}

void copyString(const char * ar,char * newString){	
	while(*ar!='\0'){			                    /*当原字符串未读取完毕时*/
		*newString++=*ar++;	/*写入新字符串中*/
	}
	*newString='\0';			                    /*给新字符串末尾加上空格符*/
}

   -----------说明: 这两个函数不是很完善,应先求出数组内元素个数,再调用.

                重点在于:函数形参用const修饰,则无法对原来的数据进行修改.

                对比之前指针的用法:

                一般指针:间接访问数据,既可以读取,也可以修改;

                 const修饰的指针:间接访问数据,只可以读取,不可以修改.