精华内容
下载资源
问答
  • C++ 常量引用用法
    千次阅读
    2022-03-11 09:21:18

    常量引用”其实是“对 const 的引用”的简称。因此不可以通过该引用来修改它所指向的对象的值。

    1)指向常量对象时,一定要使用“常量引用”,而不能是一般的引用。

    const int ci = 1024;
    const int &r1 = ci;         // 正确:引用及其对应的对象都是常量
    int &r2 = ci;               // 错误:试图让一个非常量引用指向一个常量对象
    

    (2)“常量引用”可以指向一个非常量对象,但不允许用过该引用修改非常量对象的值。

    “常量引用”仅对引用可参与的操作做出了限定,对于引用的对象本身是不是一个常量未作限定。因为对象也可能是个非常量,所以允许通过其他途径改变它的值:

    int i = 42;
    int &r1 = i;                // 普通引用指向非常量对象 i
    const int &r2 = i;          // 常量引用也绑定非常量对象 i
    r1 = 40;                     // 正确,r1并非常量引用
    r2 = 0;                     // 错误:r2是一个常量引用
    
    
    结果
    i=40
    r1=40
    r2=40
    

    (3)引用的类型必须和所引用的类型严格匹配,且不能与字面值或者某个表达式的计算结果绑定在一起,但是 “常量引用” 是例外(只要被引用的类型能够转换为常量引用的类型)。

    int i = 42;
    const int &r1 = i;          // 正确:指向非常量对象
    const int &r2 = 42;         // 正确:r2 是一个常量引用
    const int &r3 = r1 * 2;     // 正确:r3 是一个常量引用
    int &r4 = r1 * 2;           // 错误:r4 是一个普通的非常量引用
    i = 40;
    
    则
    r1 = 40;
    r3 = 84;
    
    const int temp = 2*r1;      // 生成一个临时的整型常量
    const int &r3 = temp;       // 让 r3 绑定这个临时量

     所以

    	int i = 40;
    	int &r1 = i;
    	const int &r3 = i * 2;
    	std::cout << "r3 = " << r3 << std::endl;
    	r1 = 30;
    	std::cout << "r3 = " << r3 << "    i = " << i << std::endl;//测试r3是否改变.

    r3 = 80
    r3 = 80    i = 30 

    在这些情况下,“常量引用”实际上是绑定了一个临时量(temporary)对象。也就是说,允许“常量引用”指向一个临时量对象


    (4)在函数参数中,使用常量引用非常重要。因为函数有可能接受临时对象,而且同时需要禁止对所引用对象的一切修改。

    5.去掉常量的办法是调用const_cast函数

    更多相关内容
  • c++常量详解

    2020-08-30 08:45:48
    常量是存放固定且不可变值的,一旦确定初始值则在程序其它地方不可改变, 所以const对象必须初始化。常量一般使用const关键字来修饰
  • 主要介绍了C++常量详解二(常量形参,常量返回值,常量成员函数),需要的朋友可以参考下
  • 总结: 1.常量数据成员,形式:const Type m_tData; 1)常量数据成员,需要在构造函数列表中给出,构造函数中可以用常量赋值,也可以实例化的时候...3.返回常量的函数,可以是常量指针,指针常量常量,形式: const
  • C++常量函数

    2022-04-27 21:50:47
    什么是常量函数 常量函数只能读取外部数据而无法修改。在函数声明的参数列表后加上const关键字将函数声明为常量函数: void hello() const { print("Hello!"); } 注意:const关键字位于函数声明的返回类型前时不是...

    什么是常量函数

    在类成员函数声明的参数列表后加上const关键字将函数声明为常量函数。

    class A {
    public:
    	void f() const {
    	    print("Hello!");
    	}
    }
    

    注意:const关键字位于函数声明的返回类型前时不是常量函数,只是函数的返回值为常量。

    const int f1() {...}	// 不是常量函数,函数的返回值为常量
    int f2() const {...}	// 常量函数
    

    常量函数的特性

    常量函数只能读取外部数据而无法修改。当函数较为复杂时,如果希望避免函数对对象内容进行修改,就可以将这个函数定义为常量函数。

    class B {
    private:
        int n;
    public:
        void f() const {
            n = 0;			// 错误:表达式必须是可修改的左值
        }
    };
    

    注意:

    • 常量函数可以修改在其内部定义的变量。
    • 常量函数内只能调用常量函数,不能调用非常量函数。
    class C {
    public:
        int f1() const {
            int n = 0;
            n = 1;			// 正确:常量函数可以修改在其内部定义的变量
            return n;
        }
        intf2() {
    		return 2;
    	}
    	void f3() const {
    		int a;
    		a = f1();		// 正确
    		a = f2();		// 错误:常量函数内不能调用非常量函数
    	}
    };
    

    常量函数的调用规则

    • 非常量对象可以调用常量函数和非常量函数。
    • 常量对象可以调用常量函数,不可以调用非常量函数。

    举例:

    #include <iostream>
    using namespace std;
    
    class A {
    public:
        void f1() { cout << "f1" << endl; }
        void f2() const { cout << "f2" << endl; }
    };
    
    int main() {
        A a;
        a.f1();
        a.f2();
    
    	const A b;
    	b.f1();		// 错误:对象含有与成员函数"A::f1"不兼容的类型限定符
    	b.f2();
    
        return 0;
    }
    
    展开全文
  • 主要介绍了C++常量详解一(常量指针与常量引用的初始化),需要的朋友可以参考下
  • C++常量(constant)

    千次阅读 2021-05-20 13:14:54
    在程序执行过程中,其值不能...1. 整型常量C++ 中,使用的整型常量可以用八进制、十进制和十六进制 3 种方式表示,具体如下所示:十进制整型常量是最常用的一种表示形式,如 321、-123。八进制整型常量以 0 开...

    在程序执行过程中,其值不能改变的量称为常量(Constant)。普通常量的类型是根据数据的书写形式来决定的。如 100 是整型常量,0.5 是实型常量,'q' 是字符型常量,"qianfeng" 是字符串常量。

    1. 整型常量

    在 C++ 中,使用的整型常量可以用八进制、十进制和十六进制 3 种方式表示,具体如下所示:

    十进制整型常量是最常用的一种表示形式,如 321、-123。

    八进制整型常量以 0 开头作为前缀,其数码取值为 0~7,如 025、-066。

    十六进制整型常量以 0x 或 0X 开头作为前缀,其数码取值为 0~9、A~F 或 a~f,如 0xffff、-0X15。

    整型常量在表示时,除了用前缀表示进制外,有时还需要用到后缀表示 long、unsigned 修饰符。当表示长整型常数时,需要在该数的后面加上 L 或 l,如 2345L;当表示无符号整型常数时,需要在该数的后面加上 U 或 u,如 4567U。

    2. 实型常量

    实型常量又称浮点型常量,它由整数部分和小数部分组成,其表示形式有以下两种形式:

    小数表示形式,它由数字和小数点组成,不可省略小数点,但可以省略整数部分或小数部分数字,如 1.、.21。

    指数表示形式,它由小数表示法后加 e(或 E )和指数组成,指数部分可正可负,但必须是整数,并且 e 前边必须有数字,如 1.23e-5、.23e6。

    实型常量分单精度、双精度和长双精度 3 类,它们用后缀加以区分,不加后缀的为双精度浮点型常量,如 2.12;加后缀 F 或 f 的为单精度浮点型常量,如 2.12f;加后缀 L 或 l 的为长双精度浮点型常量,如 0.56e7L。

    3. 字符型常量

    用一对单引号括起来表示的形式就是字符型常量。在内存中,字符数据以 ASCII 码的形式存储,在一定范围内可以与整数相互赋值,但含义有所不同。ASCII 码是一种给字符编码的国际标准,它以整数表示字符,比如十进制数 65,表示字符 'A'。此处注意数字与字符的区别,如 4 与 '4' 是不同的,4 是整数,'4' 是字符,对应的 ASCII 码值为 52。

    在 C++ 中,有些特殊字符用转义字符表示,转义字符以反斜杠“\”开头,后跟若干个字符。转义字符具有特定的含义,不同于字符原有的意义,故称转义字符,表 1 列出了常用的特殊字符。

    表 1:常用的转义字符及含义

    转义字符

    含义

    ASCII

    \0

    空字符

    0

    \n

    回车换行

    10

    \t

    横向跳到下一制表位置

    9

    \b

    退格

    8

    \r

    回车

    13

    \f

    换页

    12

    \\

    反斜杠符

    92

    \'

    单引号符

    39

    \”

    双引号符

    34

    \a

    鸣铃

    7

    \ddd

    1〜3 位八进制数所代表的字符

    \xhh

    1〜2 位十六进制数所代表的字符

    在表 1 中,'\ddd' 和 '\xhh' 都是用 ASCII 码表示一个字符,如 '\101' 和 '\x41' 都是表示字符 'A'。转义字符在输出中有许多应用,如想让计算机的喇叭发出响声,可以使用下面的语句。

    cout << '\a';

    如果需要在屏幕上输出以下内容:

    小 C 对小 A 说:"学 C、C++ 语言,C语言中文网是最佳之选"。

    不能使用以下方法:

    cout <

    因为双引号在C++中是有特殊作用的,上述写法会使编译器产生错误,正确的语句如下所示:

    cout <

    4. 字符串常量

    字符串常量是由一对双引号括起来的字符序列。被括起来的字符序列可以是一个字符,也可以是多个字符,还可以没有字符。如"q"、"qian"、""。字符串常量都有一个结束符,用来标识字符串的结束,该结束符是 '\0',即 ASCII 码值为 0 的空字符。

    对于初学者,经常混淆字符与字符串的概念,它们是不同的量,两者区别如下:

    字符用单引号括起来,字符串用双引号括起来;

    字符与字符串占用的内存空间不同,字符只占用一个字节的空间,而字符串占用的内存字节数等于双引号中的字符个数加1,如字符 'q' 和字符串"q"在内存中的情况是不同的,字符 'q' 在内存中占一个字节,而字符串"q"在内存中占两个字节,如图 1 所示。

    bb6991f047ece21d4aa74ddfc680f74d.png

    图 1:字符'q'与字符串"q"在内存中的表示

    5. 符号常量

    有一种特殊的常量是用标识符来表示的,称为符号常量。符号常量主要用于帮助记忆和提高程序的可读性与维护性。例如,程序中经常会用到圆周率,假设为 3.14,如果程序想提高圆周率的精度到 3.141 592 65,那么它在程序中出现的所有地方都需要做修改,大大降低了程序的维护性。

    这时如果用 PI 表示圆周率,每次使用时都写 PI,那么在需要修改PI的精度时,只需要修改 PI 的初值就可以了。在 C++ 中,为了保持与 C 语言的兼容,允许程序用编译预处理指令 #define 来定义一个符号常量,上面的圆周率可以通过如下定义:

    #define PI 3.14159265

    这条指令的格式是 #define 后跟一个标识符和一串字符,中间用空格隔开。由于它不是 C++ 语句,因此此行没有分号。在程序编译时,编译器首先将程序中的 PI 用 3.14159265 来替换,然后再进行代码编译。标识符后面的内容实际上是一个字符串,编译器本身不会对其进行任何语法检查,仅仅是在程序中将标识符简单替换为字符串,因此,有时会带来意想不到的错误。

    6. const常量

    在定义变量时,可以使用 const 关键字来修饰,这样的变量是只读的,即在程序中不能对其修改,只能读取。由于不可修改,因而它是一个符号常量,且在定义时必须进行初始化。需要说明的是,通常将符号常量中的标识符写成大写字母易于与其他标识符区分。用 const 关键字定义符号常量的格式如下:

    const 数据类型 常量名=初值表达式;

    上面的圆周率可以通过如下定义:

    const double PI=3.14159265;

    const 还可以放在数据类型名后,具体示例如下:

    double const PI=3.14159265;

    注意下面的语句是错误的:

    const double PI; //PI的值无法确定

    PI = 3.14159265; //常量值不能修改

    接下来演示通过 const 关键字定义符号常量,如例 1 所示。

    【例 1】

    #include

    using namespace std;

    const double PI = 3.14159265; //定义符号常量 PI

    int main()

    {

    double area, r = 10.0;

    area = PI * r * r; //使用符号常量 PI

    cout<< " area = " << area << endl;

    return 0;

    }

    程序执行结果为:

    area = 314.159

    在例 1 中,第 3 行通过 const 关键字定义一个符号常量 PI 表示圆周率。第 7 行中使用圆周率就可以用 PI 来代替。

    展开全文
  • C++ 常量

    2017-12-14 10:02:48
    常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。常量就像是常规的变量,只不过常量的值在定义后不能进行修改...

    常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量

    常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。

    常量就像是常规的变量,只不过常量的值在定义后不能进行修改。


    整数常量

    整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数:0x 或 0X 表示十六进制,0 表示八进制,不带前缀则默认表示十进制。

    整数常量也可以带一个后缀,后缀是 U 和 L 的组合,U 表示无符号整数(unsigned),L 表示长整数(long)。后缀可以是大写,也可以是小写,U 和 L 的顺序任意。

    下面列举几个整数常量的实例:

    212         // 合法的
    215u        // 合法的
    0xFeeL      // 合法的
    078         // 非法的:8 不是八进制的数字
    032UU       // 非法的:不能重复后缀

    以下是各种类型的整数常量的实例:

    85         // 十进制
    0213       // 八进制 
    0x4b       // 十六进制 
    30         // 整数 
    30u        // 无符号整数 
    30l        // 长整数 
    30ul       // 无符号长整数

    浮点常量

    浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

    当使用小数形式表示时,必须包含整数部分、小数部分,或同时包含两者。当使用指数形式表示时, 必须包含小数点、指数,或同时包含两者。带符号的指数是用 e 或 E 引入的。

    下面列举几个浮点常量的实例:

    3.14159       // 合法的 
    314159E-5L    // 合法的 
    510E          // 非法的:不完整的指数
    210f          // 非法的:没有小数或指数
    .e55          // 非法的:缺少整数或分数

    布尔常量

    布尔常量共有两个,它们都是标准的 C++ 关键字:

    • true 值代表真。
    • false 值代表假。
      我们不应把 true 的值看成 1,把 false 的值看成 0。

    字符常量

    字符常量是括在单引号中。如果常量以 L(仅当大写时)开头,则表示它是一个宽字符常量(例如 L’x’),此时它必须存储在 wchar_t 类型的变量中。否则,它就是一个窄字符常量(例如 ‘x’),此时它可以存储在 char 类型的简单变量中。

    字符常量可以是一个普通的字符(例如 ‘x’)、一个转义序列(例如 ‘\t’),或一个通用的字符(例如 ‘\u02C0’)。

    在 C++ 中,有一些特定的字符,当它们前面有反斜杠时,它们就具有特殊的含义,被用来表示如换行符(\n)或制表符(\t)等。下表列出了一些这样的转义序列码:

    转义序列含义
    \\ 字符
    \’’ 字符
    \”” 字符
    \?? 字符
    \a警报铃声
    \b退格键
    \f换页符
    \n换行符
    \r回车
    \t水平制表符
    \v垂直制表符
    \ooo一到三位的八进制数
    \xhh …一个或多个数字的十六进制数

    下面的实例显示了一些转义序列字符:

    #include <iostream>
    using namespace std;
    
    int main()
    {
       cout << "Hello\tWorld\n\n";
       return 0;
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    Hello   World

    字符串常量

    字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符:普通的字符、转义序列和通用的字符。

    您可以使用空格做分隔符,把一个很长的字符串常量进行分行。

    下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

    "hello, dear"
    
    "hello, \
    
    dear"
    
    "hello, " "d" "ear"

    定义常量

    在 C++ 中,有两种简单的定义常量的方式:

    • 使用 #define 预处理器。
    • 使用 const 关键字。

    #define 预处理器

    下面是使用 #define 预处理器定义常量的形式:

    #define identifier value

    具体请看下面的实例:

    #include <iostream>
    using namespace std;
    
    #define LENGTH 10   
    #define WIDTH  5
    #define NEWLINE '\n'
    
    int main()
    {
    
       int area;  
    
       area = LENGTH * WIDTH;
       cout << area;
       cout << NEWLINE;
       return 0;
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    50

    const 关键字

    您可以使用 const 前缀声明指定类型的常量,如下所示:

    const type variable = value;

    具体请看下面的实例:

    #include <iostream>
    using namespace std;
    
    int main()
    {
       const int  LENGTH = 10;
       const int  WIDTH  = 5;
       const char NEWLINE = '\n';
       int area;  
    
       area = LENGTH * WIDTH;
       cout << area;
       cout << NEWLINE;
       return 0;
    }

    当上面的代码被编译和执行时,它会产生下列结果:

    50
    请注意,把常量定义为大写字母形式,是一个很好的编程实践。
    
    展开全文
  • 常量指针与存放常量地址的指针,一般出现在函数的参数里面,传参的过程中。 存放常量地址的指针 int num = 10; int num2 = 18; const int * p1 = &num; // 等价于 int const * p1 = &num; //*p1 = 24; //...
  • C++常量

    2018-02-20 22:39:01
    C++ 常量常量是固定值,在程序执行期间不会改变。这些固定的值,又叫做字面量。 常量可以是任何的基本数据类型,可分为整型数字、浮点数字、字符、字符串和布尔值。常量就像是常规的变量,只不过常量的值在定义后不...
  • c++常量和常量表达式

    千次阅读 2019-08-03 18:49:31
    const引用:对常量的引用不能被用作修改它所绑定的对象 const int ci(5); const int &rci(ci); rci = 90;//错误 不能修改 允许常量引用绑定到非常量的对象、字面值或表达式上 int i = 20; const int &...
  • C++ 常量引用用法详解

    千次阅读 多人点赞 2020-11-23 20:37:10
    事实上,由于 C++ 语言并不允许随意改变引用所绑定的对象,所以从这层意思上理解所有的引用又都算是常量。 与普通引用不同的是,“常量引用”(对 const 的引用)不能被用作修改它所绑定的对象。 (1)指向 const ...
  • 1.常量: 1.1.#define的宏定义 #define 常量常量值 1.2.const 修饰的变量 const 数据类型 常量常量值 #include<iostream> using namespace std; //常量: //1.#define的宏定义 // #define 常量名 ...
  • C++常量存储的位置

    千次阅读 2020-08-05 23:19:56
    1、const修饰的量不是常量,仅仅是个只读量。在编译的时候全部替换const变量被赋予的值(这点和C语言的宏相似),在运行的时候该const变量可通过内存进行修改: 1.1)通过内存(指针)可以修改位于栈区的const变量,...
  • C++常量的两种声明

    2020-08-31 05:04:00
    1.宏常量:#define 宏常量常量值 //#define day 7 2.常量:const 常量名=常量值; //const age=17;
  • C++常量转换

    千次阅读 2020-04-22 10:13:08
    常量转换,第一层含义是,将常量转化为非常量,如下代码,可将p转化为非常量指针。 int * newp = const_cast<int *>(p); newp中保存的地址和p中保存的地址完全一样,唯一区别是,newp不再是一个常量指针了...
  • ’’,“c++” cout << 2020; 常量:不能改变的量 字面常量(字面量,直接常量):直接写出的数据 符号常量:用符号表示数据,但它一旦确定了表示那个数据,以后它不再改变 ①符号常量 说明一个符号表示常量 ⚮ ...
  • C++ 常量和const

    万次阅读 多人点赞 2018-07-12 14:57:57
    C++中的常量 const的说明 const的引用 4. C++常量 a. 常量: 其值在程序运行的过程中不会发生改变,但是定义常量的时候可以设置初始值。 C++中使用const关键字来定义一个常量。 //a是常量 const int a=10; ...
  • 1 常量成员函数(const member functions) class Complex { public: Complex(double r = 0, double i = 0) :re(r), im(i) {} Complex(double r) :re(r), im(0) {} Complex& operator += (const Complex&...
  • C++ 常量区 静态区 堆区 栈区

    千次阅读 2019-03-28 20:53:04
    C++ 常量区 静态区 堆区 栈区 参考博客 C++中类的变量可以通过static、const、static const来修饰,不同的修饰在不同的情况下表示不同的含义。 程序运行期间的内存分区: 1.代码区:存放CPU指令码。 2.常量区:存放...
  • 2、常量 三、例题 四、思考题 一、前言 1、上节课回顾 上一次给大家讲了C++数据类型还有C++注释,在以后的代码中,随着代码的增多,注释是必不可少的,它会提示我们代码功能,变量含义等等。所以我们要熟练掌握...
  • C/C++常量与变量的使用

    千次阅读 2017-09-29 13:55:30
    C/C++常量与变量的使用常量:定义时设置初值,编译器将其放置一个只读的内存区域。用处: 程序多出使用一个常数值时,可以用常量代替。C采用define来进行定义,eg:#define PI 3.1415;而C++采用const来定义,eg:...
  •  const常量是编译运行阶段使用。  (2) 类型和安全检查不同  define宏没有类型,不做任何类型检查,仅仅是展开。  const常量有具体的类型,在编译阶段会执行类型检查。  (3) 存储方式不同  define宏仅仅...
  • C++中,数值常量是区分类型的,从字面形式即可识别其类型。 整型常量(整数)的类型 在上一节中已知道:整型数据可分为int, short int,long int以及unsigned int, unsigned short, unsigned long等类别。整型...
  • 要理解它们的差别,需要先掌握指针、常量指针、指针常量的概念。 1.指针 指针的本质也就是变量: 它不仅有自己的地址,也有它所存放的值,只不过这个值是地址而已。 int a = 10; int *p = &a; //指针变量...
  • C++常量指针this

    2020-02-12 08:17:59
    在每一个成员函数中都包含一个常量指针,我们称其为this指针,该指针指向调用本函数的对象,其值为该对象的首地址。通过该指针,我们可以在成员函数的函数体内访问对象。其中this是C++的一个关键字。 #include<...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 272,507
精华内容 109,002
关键字:

c++常量

c++ 订阅
友情链接: nrf24l01+lcd.rar