精华内容
下载资源
问答
  • 常量和字面量的区别

    2020-12-01 08:58:36
    常量和字面量之间几乎没有区别,用良好的定义规范来命名常量可以起到替代字面量的作用。 eg: const MAX_AGE = 100 int min_age = 0 这里 100 0 都是字面量,都可以起到见名知意的作用。我们用字面量的时候...

    字面量(literal):表达的信息如字面所示,再通俗点就是表达的信息就是它自己。

    常量和字面量之间几乎没有区别,用良好的定义规范来命名常量可以起到替代字面量的作用。

    eg: const MAX_AGE = 100
        int min_age = 0

    这里 100 和 0 都是字面量,都可以起到见名知意的作用。我们用字面量的时候直接用 0 和 100表达我们的“意图”,用常量的时候需要这样

    if(v >= MAX_AGE)
    ……

    常量和字面量的编程思想是一样的,都是为了更好地阅读(不仅限于程序员)

    常量的使用范围:

    • 上下文中需多次引用同一个值;
    • 使这个值能够起到见名知意的作用。

    至于什么是变量???变量就是在程序编译和运行过程中可能出现变化的量。

     

     

    展开全文
  • 1.Java常量和字面量

    2020-03-12 16:33:02
    常量和字面量 常量:程序中固定不变的值。 常量的分类: 字面量常量:整数常量1,2,3;小数常量1.1,5.3;布尔量:true,false 定义的final常量:使用final修饰的常量。 新建ConstantDemo.java //演示常量 ...

    常量和字面量

    1. 常量:程序中固定不变的值。

    2. 常量的分类:

    3. 字面量常量:整数常量1,2,3;小数常量1.1,5.3;布尔量:true,false

    4. 定义的final常量:使用final修饰的常量。

    新建ConstantDemo.java

    
    //演示常量
    class ConstantDemo
    {
    	public static void main(String [] args)
    	{
    		/*
    			字面量常量,整数,小数,布尔常量。
    			直接给出的常量。
    		*/
    		System.out.println(12);
    		System.out.println(39.2);
    		System.out.println(true);
    		System.out.println(false);
    	}
    }
    
    展开全文
  • 原文:C++ 惯用法: const 常量和字面量 作者:Breaker <breaker.zy_AT_gmail> C++ 中 const 关键字、常量和字面量的惯用法 关键字:const, enum, const_cast, const_iterator, mutable, 左值, ...

    原文:C++ 惯用法: const 常量和字面量
    作者:Breaker <breaker.zy_AT_gmail>


    C++ 中 const 关键字、常量和字面量的惯用法

    关键字:const, enum, const_cast, const_iterator, mutable, 左值, 字面量

    本质和非本质上的常量

    字面量 (literal),是指在 C++ 中直接书写的数字、字符和字符串,如 0x3f, '+', 1.23e-15L, "hello", L"world",具体语法参考 [CPP_LANG] 4.3.1 字符 4.4.1 整数 4.5.1 浮点数 5.2.2 字符串

    左值 (l-value),是指想尽办法可以让其放到 = 左面的对象,这里的 = 是赋值而不是初始化,这里的对象可以是类类型和基本类型。想尽办法主要指强制转换和指针地址操作

    本质上的常量,指非左值,字面量、enum 枚举值是非左值

    字面量的 const 变量

    是否能通过强制而修改,由编译优化和运行平台决定,这是 Win7 VC 2010 的情况:

    通过 const_cast 修改字面量的 const 变量
    字面量的 const 变量是否能修改
    static 数字字面量 const不可修改
    non-static local 数字字面量 const可修改
    non-static local const char[]可修改
    static const char[]不可修改
    const char* 字符串字面量不可修改

    这些通过强制而修改字面量 const 变量的代码很难移植,并且不是正常的逻辑,所以认为字面量 const 变量是本质上的常量是合理的

    const T& 引用

    参考 [CPP_LANG] 5.5 引用

    和字面量的 const 变量不同,字面量的 const T& 会引用一个临时变量

    const int& g_C = 42; // 解释为: // int temp = 42; // const int& g_C = temp; // 所以强制是合理的 const_cast<int&>(g_C) = 43;

    类类型也是如此,并且 const T& 的初始值可以不是类型 T 的,会自动隐式转换,而这一点对于 non-const T& 不成立的,如:

    // std::basic_string 中有 const char_type* 的转换 ctor void func_1(std::string& str); void func_2(const std::string& str); void test() { func_1("hello"); // Error, string& 不能接受 const char[] func_2("hello"); // OK, const string& 自动隐式转换 }

    非本质的常量

    非本质的常量比本质的常量更容易理解和确定,通常是函数的 const 参数接受的 non-const 初始化,如:

    char* strcpy(char* dest, const char* src); class Widget { public: void show() const; }; void func() { char str[] = "hello world"; char str2[64]; strcpy(str2, str); // strcpy 中 src 是非本质的 const Widget w; w.show(); // Widget::show 中 this 是非本质的 const* }

    非本质的常量的目的,是在一定执行区间内约束代码(不保证区间外是否 const),产生试图修改 const 的编译错误

    常量求值

    本质上的常量,可以在编译期求值,它们或化为指令立即数,或保存在目标文件 (.obj) 和可执行文件 (.exe/.dll) 的特殊位置,如 .rdata 区段

    也因在编译期求值,本质上的常量可以作为非类型模板参数,只需注意指针类型模板参数只接受外部链接对象的地址,而字符串字面量是内部链接的,这时用外部链接的字符数组代替即可

    非本质的常量,在运行时求值

    有一些在运行时求值的非平凡情况,评估它们的常量本质性:

    // strdup 早于 main 调用 const char* g_Str = strdup("hello"); // Widget ctor 早于 main 调用 const Widget g_Widget; void func() { const_cast<char*>(g_Str)[0] = 'A'; free(const_cast<char*>(g_Str)); const_cast<Widget&>(g_Widget).move(); // 设 Widget::move 是 non-const 方法 }

    常量存储

    左值一定分配存储,因此可以取其地址

    本质的常量(非左值)不一定分配存储,是否分配由具体情况、编译优化和运行平台决定,参考 [CPP_LANG] 5.4 常量

    • enum 不分配存储

    • 字面量的 const 变量,如果不引用其地址,如创建指向它的指针或引用,则也不需要分配存储,但具体视编译优化而定

    • 类的 static 整数 const,如果不引用其地址,则可以只用声明式而不用定义式,此时不需要分配存储;如果引用其地址,则需要定义式,并且分配存储

      class Widget { static const int Num = 5; }; const int Widget::Num; // 引用 Num 地址时,需要定义式

    const 对比 volatile

    const 关键字的横向对比物是 volatile,对比两者可以更明白本质

    • 和编译优化相关

      volatile 是防止变量访问被激进优化的修饰字,volatile 变量的每次读写都会产生实际的内存访问指令,以防止因编译期不可知的因素(如并发线程的共享变量访问)而优化去除 volatile 变量的内存访问(如访问寄存器中的旧值)

      本质 const 可能被优化存储,如存储到 ROM 中

      优化一定和具体编译器与平台有关,这里 C++ 是定义一种适当的目的描述,而非实现细节,如 VC 2005+ 的 volatile 变量读写带有 Acquire/Release 语义以防止编译期指令 reorder,但仅在 IA64 上保证相同的运行时模型,x86 x64 上仍允许运行时 CPU reorder

      本质 const 的存储也是平台相关的,所以上面表格中的 const_cast 很难移植

    • 非本质的 const 和 volatile

      非本质的 volatile 此称谓并不适当,权作和 const 对比,通常是函数的 volatile 参数接受的 non-volatile 初始化,如 InterlockedExchange(volatile LONG*, LONG) 中,它的目的和 const 参数相似,是在一定执行区间内约束代码(不保证区间外是否 volatile),防止那里的激进优化

    • 用 const_cast 强制去除 const, volatile 修饰字

      const_cast 只能去除非本质 const 的 const 修饰

    • 指向 const/volatile 的指针和 const/volatile 指针,参考 MSDN: const and volatile Pointers

      const T* pc; // 指针引用物是 const T* const cp; // 指针值是 const volatile T* vp; // 指针引用物是 volatile T* volatile pv; // 指针值是 volatile

    const_iterator

    一些 STL 容器如 vector 有 iterator 和 const_iterator 两种迭代器

    vector<T>::const_iterator 是 const T*
    const vector<T>::iterator 是 T* const

    const 和 non-const 方法

    class Widget { public: void move(int x, int y); // non-const 方法 // 解释为: // void move(Widget* this, int x, int y); void show() const; // const 方法 // 解释为: // void show(const Widget* this); }; void func() { const Widget cw; Widget w; w.move(42, 84); // OK, non-const 对象调用 non-const 方法 w.show(); // OK, non-const 对象调用 const 方法 cw.move(42, 84); // Error, const 对象调用 non-const 方法 cw.show(); // OK, const 对象调用 const 方法 };

    逻辑上的 const 方法

    参考 [CPP_LANG] 10.2.7.1, 10.2.7.2 mutable

    有时我们需要在 const 方法里修改对象的状态(成员变量),这时需要用 mutable 修饰那个被修改的成员变量

    典型的惯用法:返回对象状态时,先检查其 cache 值,如果需要更新,则修改其值,如:

    class Widget { public: // 这里的计算太简单,cache 效率可能比无 cache 差,仅作示例 // 合理的场景是有复杂计算过程的方法 int area() const { if (m_size_changed) { m_area = m_height * m_width; m_size_changed = false; } return m_area; } void move(int x, int y, int dx, int dy); // 设置 m_size_changed = true private: int m_height; int m_width; bool m_size_changed; mutable int m_area; };

    从 Widget 用户的角度看,Widget::area() 是具有 const 逻辑的

    方法的 const 和 non-const 版本

    一些 STL 容器如 vector 有同一个 operator 的 const 和 non-const 两个版本,如 vector<T> 实例化后有两个 operator[]:

    class vector<T> { T& operator[](size_type p); const T& operator[](size_type p) const; };

    第一个 operator[] 可用来充当左值(准确的说是可变左值 modifiable l-value),因为所有的左值都是右值,所有它也可充当右值(注意 右值和非左值的区别)

    那第二个版本 const 版本的 operator[] 岂不是多余

    其实它和非本质 const 配合,用来约束代码,逻辑很合理:如果 vector<T> 是 const,那么每个元素都应该是 const,反之,假如元素能修改,就称不上是 const vector<T>,如:

    void print(const vector<T>& vec) { for (vector<T>::size_type i = 0; i < vec.size(); i++) cout << vec[i] << '\n'; // 作用 1: 调用第二个版本的 operator[], 因为 vec 是 const* this vec[0] = T(42); // 作用 2: 不小心写错, 但 vec[0] 是 const T&, 编译出错从而保护 }

    分清两个位置 const 的作用:

    作用 1, 返回值 const T&: 产生约束保护
    作用 2, const 方法 (const* this): 产生重载规则,C++ 不能仅通过返回不同类型重载函数

    也可以理解为,同一方法概念的两个版本:

    non-const 版: set 式方法
    const 版: get 式方法

    转接 non-const 方法到 const 方法

    虽然区分同一方法概念的两个版本,但大多数时候,const 和 non-const 版本的内部操作相同,仅在传入参数和返回值类型上不同

    为了简化重复代码,可利用 static_cast/const_cast 将 non-const 方法转接到 const 方法,如 vector<T> 的 non-const operator 可如下转接:

    T& vector<T>::operator[](size_type p) { return const_cast<T&>( // 转换 const T& 到 T&,因为事先知道 this 是非本质的 const*,所以强制是安全的 static_cast<const vector<T>&>(*this)[p]); // 转换 non-const* this 到 const* this,从而调用 const operator }

    反向的,将 const 转接到 non-const 上会违背 const 承诺,不要那么做

    参考

    [CPP_LANG] 《C++ 程序设计语言》特别版, Bjarne Stroustrup

    [EFF_CPP] "Effective C++", 3Ed, Scott Meyers, 条款 02, 03

    展开全文
  • 通常可以分为字符串字面量、整数字面量、浮点数字面量、布尔字面量、字符字面量和空字面量。 例如: "apple" 'a' 12 12.124 true false null 字面量的使用导致了诸如 Perimeter = PI * 10; 这样的语句出现,...

    字面量(literal)

    字面量是用于表达一个固定值的表示法。例如:12,3.1315926,a,true," "等等。

    通常可以分为字符串字面量、整数字面量、浮点数字面量、布尔字面量、字符字面量和空字面量。

    例如:

    "apple" 'a' 12 12.124 true false null

    字面量的使用导致了诸如

    Perimeter = PI * 10;

    这样的语句出现,其中Perimeter 和PI是假定的变量,而10是一个字面量。

    通常,使用字面量不是一个好的编程习惯,因为字面量会掩盖包含字面的语句的真实意义。当我们面对上面的语句时,我们并不清楚10是直径还是半径。此外,字面的使用会使在必要时修改程序的工作变得复杂。

    为了解决这些问题,Java语言允许为不会改变的值分配一个描述性的名字。这种名字称为常量。

    常量(Constant)

    声明常量的语法如下:

    final 数据类型 常量名称;

     

    展开全文
  • C 语言变量、常量和字面量在本教程中,您将学习变量命名变量的规则。您还将学习C编程中的不同文字以及如何创建常量。变量在编程中,变量是用于保存数据的容器(存储区)。为了指定存储区域,应该为每个变量赋予唯一...
  • 在 Jerry 的前一篇文章ABAP 标准培训教程 BC400 学习教程之四:ABAP 编程语言的数据类型里,我们实际上已经涉及到了 ABAP 字面量的一种:如下图高亮的 ‘01’ 所示,该文本字面量由两个单引号包裹的字符01组成: ...
  • 常量字面量和变量

    2020-01-05 18:00:46
    常量,变量和字面量通常很会让人疑惑它们有什么区别。 常量:在赋值之后就不可改变,具有名字,可以是基本类型也可以是自定义类型。是一个不可变的变量。 const int a = 1; // int常量 const vector<int> arr{...
  • 文章目录什么是变量和常量字面量区别:声明变量变量的命名规则规范规则 - 必须遵守的,不遵守会报错规范 - 建议遵守的,不遵守不会报错变量提升(hoisting)JavaScript 中有六种数据类型包括:五种基本数据类型...
  • 3、字面量:字面看到的赋值变量值 <script> //以下是一种定义变量并赋值的方法 var myName; var myAge; myName = "张三"; myAge = 39; //还可以在定义变量时直接赋值 var yourName = "李四"; var you...
  • //str为常量,3为字面量 变量 变量是用于存储数据的容器,在程序的运行中可以发生变化或者被再次赋值。 我们可以使用var关键字来声明变量,变量的值可以是任意类型。为了更好的阅读,建议...
  • 关于Java 变量、常量和字面量的解释 先给出一段小代码,如下: int a = 10; //a为变量,10为字面量 final int b = 10; //b为常量,10为字面量 static str = "Hello World"; //str为变量,Hello World为字面量 ...
  • 字面量 变量 常量 理解 变量常量是引用,变量值可变,常量值固定 字面量是值 例子 // str 是变量 "hjello world"是字面量 // number 是变量 10是字面量 String str = "hello world"; int ...
  • 65 变量 常量 字面量

    2017-02-08 13:11:00
    变量 就是可变的量  计算机的高级语言使用变量来管理内存中的存储数据 ... 字面量 java 的变量和常量中存放的具体数据称为字面量 转载于:https://www.cnblogs.com/panw3i/p/6377746.html...
  • 概念 : 程序中固定不变的值 ...//b为常量,10为字面量 字面量是指由字母,数字等构成的字符串或者数值,它只能作为右值出现,所谓右值是指等号右边的值, 如:int a=123这里的a为左值,123为右值。 常量和变量都属于
  • int a; //变量 const int b = 10; //b为常量,10为字面量 string str = “hello world!”; // str 为变量,hello world!为字面量
  • 字面量是指由字母,数字等构成的字符串或者数值,它只能作为右值(右值是指等号右边的值,如:int a=...// b为常量,10为字面量 final int b = 10000; // s为变量,Hello Java为也字面量 string s = "Hello Java"; ...
  • java字面量和常量

    千次阅读 2018-02-26 20:08:19
    常量:程序中固定不变化的。分类:字面值常量:整数常量eg.1 2 3; 小数常量eg.3.14; 布尔常量:true/false; 定义的final变量//常量的讲解public class ConstDome{ //主方法:程序的入口 public static void main...
  • * 1) 字符串字面量和常量称为“静态字符串” * 2) 字面量和常量的连接在编译期间执行,优化为一个静态字符串 * 3) 在运行期间,Java在静态缓冲池中创建静态字符串,并且尽量使用同一个字符串对象。 ...
  • 字面量和常量 /* * 字面量,都是一些不可变的值 * 比如:1 2 3 4 5 * 字面量都是可以直接使用的 但是我们一般都不会直接使用字面量 * * 变量 变量可以用来保存字面量 变量可以保存字面量 而且可以任意改变 ...
  • Java中的变量、常量字面量 什么是变量(variable)? 程序语言大多数时候都是在处理不同的数据,比如整型数据int,字符型数据char等。 这些不同的数据需要放在适合自己的不同容器中,这些容器就相当于是java...
  • 一篇适合初学者的文章 一.字面量(literal): 很多地方都翻译成字面量,但有点奇怪。   在计算机科学中,是...还有一些甚至对枚举类型的元素以及像数组、记录对象等复合类型的值也支持字面量表示法。   其实Li...
  • 字面量是指由字母,数字等构成的字符串或者数值,它只能作为右值出现,所谓右值是指等号右边的值,如:inta=123这里的a为左值,123为右值。 常量和变量都属于变量,只不过常量是赋过值后不能再改变的变量,而普通的...
  • java中常量和字面常量 A constant is a variable whose value cannot change once it has been assigned. Java doesn't have built-in support for constants, but the variable modifiers static and final can ...
  • 在计算机中,字面量是用于表达源代码中一个固定值的表示方法,几乎所有计算机编程语言都具有对基本值的字面量表示,比如:整数、浮点数字符串;字面量 在javascript中字面量(literal)的表现形式如下: var a =...
  • Go字面量介绍。
  • Java温习——字面量和常量

    千次阅读 2017-02-21 15:55:46
    一、概念 程序中固定不变的值; 二、分类 1 字面值常量 又直接,直接给出的值; 如,整数常量1988、小数常量3.25、布尔常量true/false; 2 final修饰的变量

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 59,432
精华内容 23,772
关键字:

常量和字面量