精华内容
下载资源
问答
  • 指针常量和常量指针
    千次阅读 多人点赞
    2022-04-10 17:09:17

    1、指针常量——指针类型的常量(int *const p)

    本质上一个常量,指针用来说明常量的类型,表示该常量是一个指针类型的常量。在指针常量中,指针自身的值是一个常量,不可改变,始终指向同一个地址。在定义的同时必须初始化。用法如下:

    int a = 10, b = 20;
    int * const p = &a;
    *p = 30; // p指向的地址是一定的,但其内容可以修改

    2、常量指针——指向“常量”的指针(const int *p, int const *p)

    常量指针本质上是一个指针,常量表示指针指向的内容,说明该指针指向一个“常量”。在常量指针中,指针指向的内容是不可改变的,指针看起来好像指向了一个常量。用法如下:

    int a = 10, b = 20;
    const int *p = &a;
    p = &b; // 指针可以指向其他地址,但是内容不可以改变

     

    3、例题

    int main() {
        int m = 10;
        const int n = 20; // 必须在定义的同时初始化
     
        const int *ptr1 = &m; // 指针指向的内容不可改变
        int * const ptr2 = &m; // 指针不可以指向其他的地方
     
        ptr1 = &n; // 正确
        ptr2 = &n; // 错误,ptr2不能指向其他地方
     
        *ptr1 = 3; // 错误,ptr1不能改变指针内容
        *ptr2 = 4; // 正确
     
        int *ptr3 = &n; // 错误,常量地址不能初始化普通指针吗,常量地址只能赋值给常量指针
        const int * ptr4 = &n; // 正确,常量地址初始化常量指针
     
        int * const ptr5; // 错误,指针常量定义时必须初始化
        ptr5 = &m; // 错误,指针常量不能在定义后赋值
     
        const int * const ptr6 = &m; // 指向“常量”的指针常量,具有常量指针和指针常量的特点,指针内容不能改变,也不能指向其他地方,定义同时要进行初始化
        *ptr6 = 5; // 错误,不能改变指针内容
        ptr6 = &n; // 错误,不能指向其他地方
     
        const int * ptr7; // 正确
        ptr7 = &m; // 正确
     
        int * const ptr8 = &n;
        *ptr8 = 8;
     
        return 0;
    }

    更多相关内容
  • 在这篇文章中,我们将解释常量指针指针常量,const pointer to const(ps:楼主以为这可以翻译成指向常量的常量指针)的区别 常量指针 让我们先来理解什么是常量指针常量指针是指指针指向的地址是常量。换句话说...
  • 指针常量和常量指针

    万次阅读 多人点赞 2018-08-22 10:53:04
    1、指针常量——指针类型的常量(int *const p) 本质上一个常量,指针用来说明常量的类型,表示该常量是一个指针类型的常量。在指针常量中,指针自身的值是一个常量,不可改变,始终指向同一个地址。在定义的同时...

    1、指针常量——指针类型的常量(int *const p)

    本质上一个常量,指针用来说明常量的类型,表示该常量是一个指针类型的常量。在指针常量中,指针自身的值是一个常量,不可改变,始终指向同一个地址。在定义的同时必须初始化。用法如下:

    int a = 10, b = 20;
    int * const p = &a;
    *p = 30; // p指向的地址是一定的,但其内容可以修改

    2、常量指针——指向“常量”的指针(const int *p, int const *p)

    常量指针本质上是一个指针,常量表示指针指向的内容,说明该指针指向一个“常量”。在常量指针中,指针指向的内容是不可改变的,指针看起来好像指向了一个常量。用法如下:

    int a = 10, b = 20;
    const int *p = &a;
    p = &b; // 指针可以指向其他地址,但是内容不可以改变

    3、例题

    (1)

    int main() {
        int m = 10;
        const int n = 20; // 必须在定义的同时初始化
    
        const int *ptr1 = &m; // 指针指向的内容不可改变
        int * const ptr2 = &m; // 指针不可以指向其他的地方
    
        ptr1 = &n; // 正确
        ptr2 = &n; // 错误,ptr2不能指向其他地方
    
        *ptr1 = 3; // 错误,ptr1不能改变指针内容
        *ptr2 = 4; // 正确
    
        int *ptr3 = &n; // 错误,常量地址不能初始化普通指针吗,常量地址只能赋值给常量指针
        const int * ptr4 = &n; // 正确,常量地址初始化常量指针
    
        int * const ptr5; // 错误,指针常量定义时必须初始化
        ptr5 = &m; // 错误,指针常量不能在定义后赋值
    
        const int * const ptr6 = &m; // 指向“常量”的指针常量,具有常量指针和指针常量的特点,指针内容不能改变,也不能指向其他地方,定义同时要进行初始化
        *ptr6 = 5; // 错误,不能改变指针内容
        ptr6 = &n; // 错误,不能指向其他地方
    
        const int * ptr7; // 正确
        ptr7 = &m; // 正确
    
        int * const ptr8 = &n;
        *ptr8 = 8;
    
        return 0;
    }

    (2)判断下面程序对错,并说明理由

    int main()
    {
        char * const str = "apple";
        * str = "orange";
        cout << str << endl;
        getchar();
    }

    错误

    "apple"是字符串常量放在常量区,str指向"apple",那么str指向的是字符串常量"apple"的首地址,也就是字符a的地址,因此str指向字符a,*str就等于字符a,对*str的修改就是对字符串首字符a的修改,但"apple"是一个字符串常量,常量的值不可修改。

    根据字符串赋值规则,可以修改整个字符串,方法是对指向字符串的指针str进行赋值,如下:

    str = "orange";

    但依旧是错误的,在该赋值语句中,系统会在常量区一块新的空间写入字符串"orange"并返回其首地址,此时str由指向字符串常量"apple"的首地址变为指向字符串常量"orange"的首地址,str指向的地址发生了变化,但str是指针常量不能被修改,所以错误。

    如果想要程序编译通过,就不能将str声明为指针常量,否则str在初始化之后就无法修改。因此将const修饰符去掉,并修改字符串赋值语句,修改后程序如下:

    int main()
    {
        char * str = "apple";
        str = "orange";
        cout << str << endl;
        getchar();
    }

    参考《程序员面试笔记》

    展开全文
  • C++指针常量和常量指针 1.指针常量:int * const p=&a; 指针的指向不可以改,指向的值可以改 例如: 2.常量指针:const int *p=&a; 指针的指向可以更改,指向的值不可以更改

    C++指针常量和常量指针


    1.指针常量:int * const p=&a;

    指针的指向不可以改,指向的值可以改
    例如:
    在这里插入图片描述


    2.常量指针:const int *p=&a;

    指针的指向可以更改,指向的值不可以更改
    在这里插入图片描述

    3.同时不可修改:const int * const p=&a;

    特别地,当我们想指针的指向和指向的值都不可以修改时,可以结合上面两个,写两个const
    如下图:
    在这里插入图片描述

    展开全文
  • 指针常量和常量指针 1.常量指针 const int *PtrConst 或者是 int const *PtrConst (即const 在*的左边) 指向常量的指针,这里所说的“常量”其实在解引用时起到所谓常量的作用,并非是指向的变量就是常量,指向的...


    1.常量指针

     const int  *PtrConst 或者是 int const  *PtrConst (即const 在*的左边)
    指向常量的指针,这里所说的“常量”其实在解引用时起到所谓常量的作用,并非是指向的变量就是常量,指向的变量既可以是非常量也可以是常量。总体意思是不能修改指向某变量的值。

    让指针指向一个常量,可以防止使用指针来修改所指向的值。

    1.常量指针指向的对象不能通过这个指针来修改,可是仍然可以通过原来的声明修改;

    	int a = 1;
    	const int *p = &a;
    	std::cout << *p << a << std::endl;
    	a = 2;//可以
    	std::cout<< *p << a << std::endl;
    
    结果
      *p = 2;
       a = 2;
    
    如果是  *p = 3; //报错
    
    

    因为不能通过这个指针来修改,所以可以用常量指针当函数的参数使用。
    2.指针还可以指向别处,因为指针本身只是个变量,可以指向任意地址;

    	int a = 1;
    	const int *p = &a;
    	std::cout << "p= "<< *p <<";" << "a=" << a << std::endl;
    	int b = 2;
    	p = &b;
    	std::cout<<"p= "<<  *p << ";" <<"b=" <<  b<< std::endl;
    
    p= 1;a=1
    p= 2;b=2

    延伸:

    1.可以将const 变量的地址赋给指向const 的指针(即常量指针)。

     如 const  int  a = 1;   const int * p = &a;//可以

    2.不可以将const 的地址赋给常规指针。

    如 const  int  a = 1;    int * p = &a;//不可以

    除非使用强制类型转换,const_cast

        const int a = 1;
        int *p = const_cast<int*>(&a)//可以

    2.指针常量:

    int  const  *PtrConst;
    本质是一个常量,而用指针修饰它。指针常量的值是指针。

    1.必须初始化,只能指向一个变量,绝不可再改变指向另一个变量

       //int *const ConstPtr;//报错,error C2734: “ConstPtr”: 如果不是外部的,则必须初始化常量对象

        int a=1;    int *const ConstPtr=&a; //可以
        int b = 2;   ConstPtr=&b;   //不可以

    2.指向的地址所对应的内容可以变化。

    int a=1;    int *const ConstPtr=&a;    ConstPtr = 3; //可以

    如果出现在星号两边,表示被指物和指针都是常量。
     

    展开全文
  • 所以指针常量:首先是常量,然后是一个指针,即是该指针是一个常量,指针的值,即指向的地址不会变。 常量指针:首先是指针,指针指向的是常量,该指针所指向的值是个常量。 然后对于类型 const,除了const在类型...
  • C语言 指针常量和常量指针的区别
  •   同理,我们先不讲技术,先从字面意思来理解:指针常量常量指针、函数指针、指针函数、数组指针、指针数组 指针常量 指针是定语,常量是中心词,所以指针常量本质是一个常量 常量指针 常量是定语,指针...
  • 1、指针常量 #include<stdio.h> int main() { double rates[5] = {88.99, 100.12, 59.45, 183.11, 340.5}; double *const prt = rates; prt = &rates[2] ; //系统报错,不允许 return 0; } #...
  • 参考链接: ...倒着读: char * const s s is a const pointer to char,翻译:s是一个常量指针(所以s的指向是固定的),指向char类型,但s的指向地址的内容是可变的 const char * s; s is
  • 常量指针和指针常量和常量指针常量 **常量指针:**指向常量的指针。 示例一: int n = 10; const int *p = &amp;amp;n; 此时不能通过指针修改数据对象的值,但可以改变指针的指向。比如此时指针p不能改变n的值...
  • 一、常量指针:指向常量的指针。 int const *p(const int *p); p = &a; p可以改变指向,可以指向常量非常量,但不能用*p修改指向变量的值。 二、指针常量:常量,存放的地址不能改变。 int *const p = &...
  • 常量指针和指针常量

    2022-01-21 12:59:13
    上面的p表示的是,一个常量指针。在上面一行语句中,const在右,对p1有最直接影响。 *在左,表明这是一个指针。那么,c++语言是* const,则中文是常量指针。 就目前来看,我们并不了解常量指针是什么意思。(因为我...
  • 指针常量和常量指针 1. 定义: 常量指针是指--指向常量的指针,顾名思义,就是指针指向的是常量,即,它不能指向变量,它指向的内容不能被改变,不能通过指针来修改它指向的内容,但是指针自身不是常量,它自身的值...
  • 常量:const int int const ...常量指针:const int* int const * 声明有两种形式: const int *p; int const *q; 只要const位于*的左侧,无论它在类型名的左边或右边,都声明了一个指向常量的指
  • 指针常量常量指针

    2020-04-29 10:59:32
    指针常量和常量指针都离不开const关键字,我们先来了解一下什么是const关键字,const被用来定义常量,如果将一个变量加上const关键字,则被修饰的变量的值将无法改变。这个变量的值只能被访问,无法被修改。const...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 356,878
精华内容 142,751
关键字:

指针常量和常量指针