精华内容
下载资源
问答
  • const intconst int *、int *cosnt、const int * cosnt、const int &的区别
    2018-01-04  创建人:Ruo_Xiao
    2018-10-17  修改人:Ruo_Xiao
    邮箱:xclsoftware@163.com
    修改内容:增加对 delete 指向常量的指针的可行性的说明。 
    2019-02-20  修改人:Ruo_Xiao
    修改内容:增加对const的附加值的说明。
    

    零、const的今世来生

    1. 关键字又叫做限定符,因为它限定了声明的含义
    2. 英文全称:constant,意义就是常数,故被const修饰的变量类型都是常类型,即不可改变。
    3. C中的const,在C90(ANSI C 或者 C89)中加入的关键字(之前有个K&R C )。
    4. C++中的const,暂时在网上没有找到相关介绍。由于C语言是在1972年至1973间创建的,而1990年在C90中加入了const,所以C++中的const大概是在其之后加入的。
    5. 目的:取代#define。

    一、const int

    在定义变量的时候必须初始化,否则报错。

    #include "stdafx.h"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	const int i = 0;
    	//i = 4;             //error C3892: “i”: 不能给常量赋值
    
    	//error C2734: “k”: 如果不是外部的,则必须初始化常量对象
    	//const int k;       
    	//k = 3;             //error C3892: “k”: 不能给常量赋值
    	return 0;
    }
    

    二、const int *

    1、声明该指针变量指向的是常量,即该指针变量的内容可以改变,但是该内容指向的内容不可改变!

    #include "stdafx.h"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	const char *p = "Hello world!";
    	//p[3] = '3';  //error C3892: “p”: 不能给常量赋值
    	p = "Hi!";
    	return 0;
    }
    

    2、虽然指向的内容不可改写,但是delete则是可以的。栗子:

    	const int *p = new int[3];
    	delete []p;
    	p = nullptr;
    

    因为delete只是告诉系统,现在p所指向的这块内存已还给自由存储区,不再被使用,可以被其他程序改写。而此时p依旧指向这块不可使用的内存,故需要对p进行清零。

    三、int *const

    声明该指针变量为常变量,即指针变量里面的内容不可改变,但是该内容指向的内容可以改变!

    #include "stdafx.h"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	char *const p = "Hello world!";
    	p[3] = '3';  
    	//p = "Hi!";  error C3892: “p”: 不能给常量赋值
    	return 0;
    }
    

    四、const int * cosnt

    声明该指针变量里面的内容不可改变,同时该内容指向的内容亦不可改变。

    #include "stdafx.h"
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	const char *const p = "Hello world!";
    	//p[3] = '3';  //error C3892: “p”: 不能给常量赋值
    	//p = "Hi!";   //error C3892: “p”: 不能给常量赋值
    	return 0;
    }
    

    五、const int &

    在引用前面加上const,代表该引用为常引用,即被引用的对象不可改变。若是在形参中使用,则不可达到在函数里面修改变量值的目的。

    #include "stdafx.h"
    #include <iostream>
    using namespace std;
    
    int add (const int &a,int &k)
    {
    	//a += 7;  //error C3892: “a”: 不能给常量赋值
    	k += 8;
    	return (a+k);
    }
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	int a = 5;
    	int k = 9;
    	const int &b = a;
    	//b = 7;  //error C3892: “b”: 不能给常量赋值
    	int t = add(a,k);
    	cout<<"a = "<<a<<endl;
    	cout<<"b = "<<b<<endl;
    	cout<<"t = "<<t<<endl;
    	cin.get();
    	return 0;
    }
    

    结果:
    这里写图片描述

    所以,如果想将形参作为函数的输出,同时使用了引用的方法,切记不要在引用前面使用const!

    六、总结

    以上总结了const的具体功能,其附加值也是很高的。
    1、增加代码的可读性。可以明确向读你代码的人传递该形参、变量的可操作性。
    2、合理的const可以让编译器帮你保护你的变量,即:减少bug的出现。

    (SAW:Game Over!)

    展开全文
  • C++学习笔记:const int a, int const a, const int * ptr, int const * ptr, int * const ptr, const int * const ptr 辨析const int a 与 int const a:const int * ptr 与 int const * ptr:int * const ptr:...

    C++学习笔记:const int a, int const a, const int * ptr, int const * ptr, int * const ptr, const int * const ptr 辨析

    const int a 与 int const a:

    完全等价,其作用均为声明一个常量a,其值后续操作中不可被修改。(声明时必须进行初始化

    const int * ptr 与 int const * ptr:

    完全等价,其作用均为声明了一个指向整型常量的整型指针ptr,使用过程中,指针指向内存空间的内容不可被修改,但指针的指向可以被修改

    int * const ptr:

    声明了一个指向整型变量的常指针ptr,使用过程中,ptr所指内存空间的内容可被修改,但ptr指向固定不可被修改

    const int * const ptr:

    声明了一个指向整型常量的常指针ptr,使用过程中,ptr所指空间的内容及ptr的指向均固定不可被修改

    展开全文
  • 很简单的来说,const int&是引用传值的方式,const int是值拷贝的方式 引用传值,简单的来说,就是把内存地址传过来,本身没有重新分配一块内存,而值拷贝的方式,则是重新从内存中分配一块出来保存该值,这样...
    • 很简单的来说,const int&是引用传值的方式,const int是值拷贝的方式
    • 引用传值,简单的来说,就是把内存地址传过来,本身没有重新分配一块内存,而值拷贝的方式,则是重新从内存中分配一块出来保存该值,这样内存消耗增加,而且花的时间更多。
    • 简单的代码示例
    int QuoteSwap(const int &a,const int &b)
    {
    	cout <<"引用传值" <<&a << endl;
    	cout <<"引用传值" << &b << endl;
        return 0;
    }
    
    int ValueSwap(const int a,const int b)
    {
    	cout <<"值拷贝" << &a << endl;
    	cout <<"值拷贝" <<&b << endl;
    	return 0;
    }
    
    
    
    int _tmain(int argc, _TCHAR* argv[])
    {
    	const int a = 2;
    	const int b = 3;
    	std::cout << &a << endl;
        std::cout << &b << endl;
    	QuoteSwap(a,b);
    	ValueSwap(a,b);
    	system("pause");
    	return 0;
    }
    

    运行结果:
    在这里插入图片描述
    可以明显看出引用传值的地址 还是原先的 ,值拷贝则重新分配了一块内存。

    • 结论:
    • 能使用引用传值的情况下,尽量使用引用传值,减少内存的消耗,而且系统运行时间还能减少(当然,这运行时间差不了太多。)
    展开全文
  • const int p 与 int const p 和const int const *p区别 一、何为const const修饰的数据类型是指常类型,常类型的变量或对象的值是不能被更新的。也就是说const常量,具有不可变性。 例如: const int Max=100; ...

    const int * p 与 int const* p 和const int const * p区别

    一、何为const

    const修饰的数据类型是指常类型,常类型的变量或对象的值是不能被更新的。也就是说const常量,具有不可变性。
    例如:

    const int Max=100; 
    Max++; //操作错误
    

    二、 指针常量与常量指针

    1、指针常量

    指针就是内存单元的地址,所谓指针常量,也就是这个指针变量的值不可改变,即指针只能唯一的指向一个地址,这个地址所对应的内存单元中的内容可以被修改

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

    eg:

    //如果不想要看到错误信息的话,注释掉#define CONFIG_DEBUG这句  
     
     #define CONFIG_DEBUG
     
     int a, b;
     int * const p = &a; // 定义了一个只能指向a的地址的指针
     *p = 666; //操作成功
     
     #ifdef CONFIG_DEBUG
     p = &b; //操作失败,指向的地址不可更改
     #endif
    
    补充:一种借助于指针常量思想的寄存器读写方法

    参考来源#define GPBCON (*(volatile unsigned *)0x56000010) 的理解,在此表示感谢

    #define GPJ0CON 0xE0200240
    #define GPJ0DAT 0xE0200244
    
    #define rGPJ0CON *((volatile unsigned int *)GPJ0CON)
    #define rGPJ0DAT *((volatile unsigned int *)GPJ0DAT)
    // 该函数要实现led闪烁效果
    void led_blink(void)
    {
    	int val = 0;
    	//rGPJ0CON = 0x11111111;
    	rGPJ0CON &= ~((1 << 12) | (1 << 16) | (1 << 20));
    	rGPJ0CON |= ((1 << 12) | (1 << 16) | (1 << 20));
    
    	rGPJ0CON = 0x11111111;
    
    	while (1)
    	{
    
    		// led亮
    		rGPJ0DAT = ~((1 << 3) | (1 << 4) | (1 << 5));
    		// 延时
    		delay();
    		// led灭
    		rGPJ0DAT = ((1 << 3) | (1 << 4) | (1 << 5));
    		// 延时
    		delay();
    	}
    }
    

    以(volatile unsigned char *)0x20为例,我们来分析一下,它是由两部分组成:

    1)(unsigned char *)0x20,0x20只是个值,前面加(unsigned char *)表示0x20是个地址,而且这个地址类型是unsigned char ,意思是说读写这个地址时,要写进unsigned char 的值,读出也是unsigned char 。

    2)volatile,关键字volatile 确保本条指令不会因C 编译器的优化而被省略,且要求每次直接读值。例如用while((unsigned char *)0x20)时,有时系统可能不真正去读0x20的值,而是用第一次读出的值,如果这样,那这个循环可能是个死循环。用了volatile 则要求每次都去读0x20的实际值。

    那么(volatile unsigned char *)0x20是一个固定的指针,是不可变的,不是变量。 而char *u则是个指针变量。

    再在前面加解引用 *

    *(volatile unsigned char *) 0x20
    

    则变成了变量(普通的unsigned char变量,不是指针变量),如果,

    #define i (*(volatile unsigned char *)0x20)
    

    那么这便与unsigned char i是一样了,只不过前面的i的地址是固定的。

    也就是说,(*(volatile unsigned char *)0x20)可看作是一个普通变量,这个变量有固定的地址,指向0x20。而0x20只是个常量,不是指针更不是变量。这和指针常量的思想是相通的

    2、常量指针

    const int* p=&a;	 //常量指针
    
    #define CONFIG_DEBUG
    
    int a, b;
    const  int * p = &a; // 定义了一个常量指针 
     p = &b; //操作成功 
    
    #ifdef CONFIG_DEBUG
    *p = 666; //操作失败,指向的地址中的内容不可更改
    #endif
    

    只要你想让你指向的内存单元中的内容具有像常量那样的不可变性,就可以用常量指针去指向它,常量指针可以指向任何类型的变量的地址。
    就像给小屋(内存单元)里的东西(内容)贴了封条,屋门上上了一把锁,即便是用钥匙打开了屋门(通过指针访问内存单元内容),里面的东西也不允许再改动了。
    所以其指向的内存单元中的内容不可被修改。

    3、常量指针搭配指针常量

    const  int * const p =  &a;
    

    我们暂且先不管它叫什么名字,这种搭配就好像是
    一间上了锁的房子(内存单元);
    里面的东西(内存单元中的内容)被贴上封条(const性质);
    管家只允许拥有这一间房子的钥匙,所以管家只能打开这一件房子的房门,多了没有;(指针常量被const修饰)

    也就是指针常量指向的地址不可修改,被指向的地址中的内容也不可被修改。那至于这种用法叫什么名字,我们可以叫它指向为常量的常量指针

    本文参考了 https://blog.csdn.net/weibo_dm/article/details/80445205

    展开全文
  • const int *p、int const *p、int * const p和const int * const p的学习1. const int *p、int const *p是一个东西代码运行如下:2.int * const p代码运行如下:3.const int * const p代码运行如下: 1. const int *...
  • 1)const int a; int const a;  这两个写法是等同的,表示a是一个int常量。 2)const int *a; int const* a; 表示a是一个指针,可以任意指向int常量或者int变量,它总是把它所指向的目标当作一个int常量。 3)...
  • const int a; int const a; const int * a; int * const a; int const * const; 之间的区别const int a; int const a; 这两个写法是等同的,表示一个是一个INT常量。const int * a; 表示a是一个指针,可以任意指向...
  • 这里const 修饰的是int,而int定义的是一个整值 因此*a 所指向的对象 值 不能通过 *a 来修改,但是 可以重新给 a 来赋值,使其指向不同的对象 eg:  const int *a = 0;  const int b = 1;  int c =...
  • const int a =1 / int const a=1变量a的值不能改变const int *a=&amp;b指针变量a指向的值不能改变int * const a=&amp;b指针的指向不能改变int const *const a=&amp;b指针指向不能改变,指向的值也不能...
  • 请问下面两句的实质区别,还有为什么作为数组维度会...const int a = 1; const int& a = 1; ``` const int a = 1; int b[a]; // 正确 const int &a = 1; int b[a]; // 错误:“表达式必须含有常量值” ```
  • //int const* func(const int&) | const int* func(const int&) | int *func() const区别 //const一般有三种用处:修饰函数参数;修饰函数返回值;const成员函数。 //如果函数返回值采用“值传递方式”,由于函数会...
  • 前言:很多人都把const int * 、int * constint const* 的区别和联系搞混,我自己在学习C++的过程中,也经常性 弄不 清楚,今天特意总结一下,作为学习笔记记录下来。 一,const修饰符用于指针  将const用于...
  • 这里const 修饰的是int,而int定义的是一个整值 因此*a 所指向的对象 值 不能通过 *a 来修改,但是 可以重新给 a 来赋值,使其指向不同的对象 eg:  const int *a = 0;  const int b = 1;  int c = 1;  a
  • 一、”const int” & “int const”  我们需要明白,const放在数据类型(int)前面和数据类型(int)后面是一样的,等价。所以  const int *ptr = int const *ptr  二、简单理解“const int...
  • <p>I always mess up how to use <code>const int*, <code>const int * const, and <code>int const *</code> correctly. Is there a set of rules defining what you can and cannot do? <p>I want to know all ...
  • 1、const int *p 和 int const *p,表达的意思都一样,p这个指针可以改变,但是p这个指针指向的内存存储的内容不可以改变。 2、int * const p,表达的意思是,p这个指针的指向不可以改变,你不能再把其他的地址赋值...
  • const int i; int const p; int *const p;

    千次阅读 2015-07-21 15:09:33
    1)先从const int i说起。 使用const修饰的i我们称之为符号常量。即,i不能在其他地方被重新赋值了。注意:const int i与int const i是等价的,相同的,即constint的位置无所谓。 2)const int *p 看例子: int i1...
  • int *constconst int*

    千次阅读 2018-12-12 15:39:47
    int *const a——&gt;a是指向整数的常量指针,指针本身只读 const int* b——&gt;b是指向常量整数的指针,整数本身只读 const 离谁近就是修饰谁的。  
  • 我觉得遇到这种题,从“结合律”的角度来看就很好理解,先看两个简单的,比如const int a 和 int const a。const int a里的constint结合,是一个意思是一个整型的常量,a作为一个整型常量,是不能改变的;再看 ...
  • const intINT const区别

    2011-07-18 17:15:46
    const intINT const区别2010-04-09 23:26const int a = 5; int const b = 6; 没区别 指针的时候有区别,引用也有区别指针的话 1。int* const 2。const int* 3。int const* 这三个2,
  • 前言:很多人都把const int * 、int * constint const* 的区别和联系搞混,我自己在学习C++的过程中,也经常性 弄不 清楚,今天特意总结一下,作为学习笔记记录下来。 一,const修饰符用于指针  将const用于...
  • 概述 一个指针是有两个属性的,一个是它指向的地方,一个是它指向地方上的内容。两者的差别也在此。const究竟修饰的是什么。 代码 #include <... const int *m=&p; int const *n=&q...
  • <p>I always mess up how to use <code>const int*, <code>const int * const, and <code>int const *</code> correctly. Is there a set of rules defining what you can and cannot do? <p>I want to know all ...
  • const int a; int const a; 这两个写法是等同的,表示a是一个int常量。 const int *a; 表示a是一个指针,可以任意指向int常量或者int变量,它总是把它所指向的目标当作一个int常量。也可以写成int const* a;含义...
  • 这里const 修饰的是int,而int定义的是一个整值 因此*a 所指向的对象 值 不能通过 *a 来修改,但是 可以重新给 a 来赋值,使其指向不同的对象 eg:  const int *a = 0;  const int ...
  • 使用C++也有些年了,这个语言确实有诸多繁琐和变态的地方,比如这次要说明的const int*、int const*以及int *const的区别就是一例。相信不少同学都会对这其中的差异表示不解,我尝试着用一段代码来对他们进行区别。 ...
  • 首先注意,const int * p 和int const *p 是一样的,并且不管是不是*p,即使const int i和int const i也是一样的,所以我们接下来只讨论int const * p和int * const p的不同 对于这种问题,我们只用将const 的位置固定,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 208,743
精华内容 83,497
关键字:

constint