关于C的关键字——const的理解和用法小总结

转载 2006年06月23日 23:47:00

                               关于C的关键字——const的理解和用法

    const在C中的用法很灵活(相信C++中也一样),,有时候感觉const很好用,同时又经常会因为它的优点而犯错,犯错的原因除了粗心之外,另一个更重要的,就是以前对const理解不到位。于是自己写成一篇小总结。写的都是很肤浅的东西。

    上面写了一段废话,就算是小序吧^_^ 接下来就是正文;

    一、关于const的具体定义:

       ——感觉很难对它下一个标准的定义,因为的用法很灵活,似乎对它定义后总无法让人能够明白它的意思,而且容易让人产生误解(偶水平太菜了)。例如,如果把它这样定义:一个能够让变量变成无法修改的常量的关键字。那么,这样的话,就可能让人误解为只要有const在定义变量里面,那变量就无论怎样都无法修改。这样的理解是比较片面的(下面用法方面将对这问题做探讨)。因此,不敢对它下定义,其他参考书(我看过的)好象也没有下定义。

    二、关于const的具体作用

        ——const作用就灵活了,一个表达式中const放置的位置不同,效果可能就不一样了。下面分具体情况分析(当然,所举的情况并非覆盖全部情况)

        A、const最经常的用法

           1.为了防止传递的函数参数不被修改,在调用函数的形参中用const关键字.
              
               /*--------------------- EXAMPLE ---------------------------*/

               int FindNum(const int array[], int num, int conut);//声明函数

               //code...

               int FindNum(const int array[], int num, int count)
               {
                          int i;
                          int flag = 1;

                          for (i = 0; (i < count) && flag; i++)
                          {
                                   if (array[i] == num)
                                   {
                                           flag = 0;
                                           break;
                                   }
                           }
                           return flag;
                }
                //code...
               
      上面这例子中,编译器会把array[]当作常量数据的数组看待。所以,假如你不小心给数组赋值,那么,编译器就会报错了。因此,当你不需要也不想修改数组的数据时,最好用const把数组定义为常量数组。


           2.const可以用来创建数组常量、指针常量、指向常量的指针等:
             const char ch = 'a';
             const int a[5] = {1, 2, 3, 4, 5}; 
             const int *p = a;           //a是一个数组的首地址.p是指向常量的指针
             int * const p = a;          //a是一个数组的首地址.p是指针常量;
             const int * const p = a;    //a是一个数组的首地址。p是指向常量的指针常量

      前两种情况很简单,就是把后面的变量转换成常量,这样变量就不可以修改了。现在着重分析一下后三种用法,因为这3种情况容易出错,偶就有时候怕用错了刚脆不用const.

             /*------------------------后三种情况举例分析----------------------*/

             int a[] = {1, 2, 3, 4, 5};

             ——const int *p = a;     //p是指向常量的指针,const修饰的是int *p.因此,不可以通过给指针赋值来改变数组中的数据,但指针可以移动.例如:
                                       // *p = 10;       /*错误*/
                                       // *(p + 2) = 1;  /*错误*/
                                       //可以这样理解:P就要指向a,所以它不可以改变它其中任何一个
                                       //元素的值。但是a就不一样了,它是自由的,它想怎么改变值就怎么
                                       //改变。                                                           

             ——int * const p = a;    //看这表达式,const的位置和第一个不同吧!他们的用法和作用就完全不一样了。这时候p是指针常量,我们知道,指针是指向 了一个数组的首地址,那么,它的位置就不可以改变了。因此,指针P不能移动.但是它指向数组第一个数据,所以它可以而且只 可以改变数组第一个数据的值。这一点请别误解,指针常量只是它的地址不可以改变,并不是它指向的内容一定不可以改变!
                                       //下面举几个例子:
                                       //  *p = 2;          /*可以*/
                                       //  *(p+1) = 10;     /*可以*/
                                       //  p++;             /*不可以*/

           ——const int * const p = a; //假如前面两种表达式的本质你理解了,这种表达式你来理解根本没有问题,const现在有两个,而且一个const的位置是第一种情况的位置,第二个const是第二种情况的位置,所以这表达式的功能就是前两种情况的作用总合。这里不多说!
                                        //下面举几个例:
                                        //  *p = 2;          /*不可以*/
                                        //  *(p + 2) = 10;   /*不可以*/
                                        //  p++;             /*不可以*/

        B、const并不会阻止参数的修改

        之所以把这作为一点来谈,就是因为有一些朋友可能会以为在函数参数中用了const就一定不可以改变参数,这实际上是错误的理解,因为,它并不阻止参数的修改,下面举个简单的例子来阐述一下;

           #include<stdio.h>
           #include<ctype.h>
          
           void ChangeStr(const char *String);
 
           int main(void)
           {
                    char str[] = "The C programme";

                    ChangeStr(str);
                    printf(str);
                   
                    system("Pause");
                    return 0;
            }

            void ChangeStr(const char *String)
            {
                    char *Source = (const char *)String;
              
                    while (*Source)
                    {
                               *Source = toupper(*Source);
                               Source++;
                    }
             }

             //end

      上面的程序把字符串中的每个字符都转换成大写字母了。因为*String把地址给了*Source,而*Source的值的改变编译器并不干涉,可能有的编译器会发出警告之类。上面的程序只是为了说明const并不会阻止参数的修改,如果象上面程序那样,个人感觉没什么意义,只会让人容易混乱而已。


      C.关于const其他一些杂问题
       
      下面的例子是这关键字一些比较杂的问题,也许上面B的内容可以归结到这点,但因为下面的一些表达可能是本身有问题,但编译器却没有干涉这样的问题,所以没有把B归到这部分.
       
      1.下面先看看一个例子:

/*---------------------EXAMPLE---------------------*/

#include<stdio.h>

int main(void)
{
    const int a = 2;
    const int b=0;
    const int *pt=&a;a
   
    printf("%d/n", *pt);     //2
    scanf ("%d",pt);         //  pt = 4;
   
    printf("%d/n", *pt);     // pt = 4;
   
    pt = &b;                 // pt = 0;
   
    scanf("%d", pt);          // pt = 6;
    printf("%d  %d/n", *pt, b);   // pt = 6, b = 6
   
    system("pause");
    return 0;
}

/*---------------在 VC++ 和 DEV-CPP 下结果是这样的----------*/

//也许你已经可以看到这代码里面的问题了.
//scanf ("%d",pt); ==>这句我认为本身就有问题,但是在编译器里并没有发现这个问题.因为直接给指针赋值这样虽然
//可能编译器没有发出错误信息,但这本来就是不允许的. 上面的代码在LCC编译器下却不是这样.在LCC下,b的值并没有//随着指针pt的改变而改变.实际上,先不管给指针赋值是否合法,我的看法是b不能随着指向它的指针值的改变而改变.
//这是一个小插曲.偶认为这种代码没有什么价值和意义.

     2.先看代码:
   
       //code
      
       char *p = "abcdef";  //在现代编译器下,在 char 前面实际上省略了 const;所以P的值不可以改变,
                            //一改变编译器立刻报错!但是在TC下,这样的定义,P的值却可以改变,因为它前面
                            //并没有const来修饰,所以要把P转换成常量,加const.


      关于CONST的用法和理解本人也就只能说这么多了,当然,很可能有更多高级或者少用的用法,由于水平和经验有限,确实不能再说些什么。怎么感觉自己写到最后越写越乱啊!

  三、参考文献
      ——《C primer plus 5th》    

                                                                       
                                                                            2006.5.21
                                                                         

 

 

 

 

C的关键字——const的理解和用法

关于C的关键字——const的理解和用法     const在C中的用法很灵活(相信C++中也一样),个人感觉对之既爱又恨,有时候感觉const很好用,同时又经 常会因为它的优点而犯错,犯错的原因...
  • cgbabc
  • cgbabc
  • 2011年11月02日 16:56
  • 81

关键字register static const #define用法总结

关键字registe请求编译器尽可能的将变量存在CPU的寄存器中。有以下几点注意的地方。 对register的使用是有限制条件的,这个体现在具体硬件上。 每个函数中只有很少的变量能够存放在寄存器中...

C++学习笔记:C的继承与超越——const关键字

C语言中也有const关键字,但是它却是一个不地道的常量关键字。 const int MAX = 100; int a[MAX];在C语言编译器下,定义数组的这条语句往往会报错。定义数组大小需要的是常...

【C++】const关键字用法总结

C++关键字const用法,总结了网络和C++ Primer的一些重要知识点,可能还有一些遗漏欢迎补充。 CONST是C++中常用的类型修饰符,常类型是指使用类型修饰符const说明的类型,常类型的变...

c const关键字理解

const关键字 1. const关键字含义 在c语言中,const关键字修饰的变量表示是只读的,不可修改的,所以必须在定义的时候就对它进行初始化,例如: #include const ...

C/C++中static,const,inline三种关键字详细总结

一、关于static static 是C++中很常用的修饰符,它被用来控制变量的存储方式和可见性,下面我将从 static 修饰符的产生原因、作用谈起,全面分析static 修饰符的实质。 s...

C/C++中static,const,inline三种关键字详细总结

 一、关于static static 是C++中很常用的修饰符,它被用来控制变量的存储方式和可见性,下面我将从 static 修饰符的产生原因、作用谈起,全面分析static 修饰符的实质。 ...

C/C++关键字const作用总结

(1)在C语言中用const去修饰一个变量,表示这个变量是只读的,不可通过显式的调用a去修改a的值,并且此时a仍然是一个变 量,不能等同于常量(不可修改的变量); (2)要注意const在...

C/C++中static,const,inline三种关键字详细总结

一、关于static static 是C++中很常用的修饰符,它被用来控制变量的存储方式和可见性,下面我将从 static 修饰符的产生原因、作用谈起,全面分析static 修饰符的实质。 s...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:关于C的关键字——const的理解和用法小总结
举报原因:
原因补充:

(最多只允许输入30个字)