精华内容
下载资源
问答
  • 问题可以简述成如下代码,编译不会通过。。。。。编译错误提示:错误:不兼容的类型:Color无法转换为Transport(具体的语句不同有不同的错误提示)。。。。。。。enum A {...........}enum B {...........}A a;a = ...

    问题可以简述成如下代码,编译不会通过。。。。。编译错误提示:错误:不兼容的类型:Color无法转换为Transport(具体的语句不同有不同的错误提示)。。。。。。。

    enum A {...........}

    enum B {...........}

    A a;

    a = B.XXX;



    展开全文
  • 常量是一块只读的内存区域,常量一旦被初始化就不能被改变。变量命名字母、数字、下划线组成,不能以数字开头,前文有说不在赘述。变量赋值Python中的变量不需要声明,变量的赋值操作即是变量的声明和定义的过程。每...

    变量是计算机内存中的一块区域,变量可以存储规定范围内的值,而且值可以改变。基于变量的数据类型,解释器会分配指定内存,并决定什么数据可以被存储在内存中。常量是一块只读的内存区域,常量一旦被初始化就不能被改变。

    变量命名字母、数字、下划线组成,不能以数字开头,前文有说不在赘述。

    变量赋值

    Python中的变量不需要声明,变量的赋值操作即是变量的声明和定义的过程。每个变量在内存中创建都包括变量的标识、名称、和数据这些信息。

    Python中一次新的赋值,将创建一个新的变量。即使变量的名称相同,变量的标识并不同。

    x = 1 #变量赋值定义一个变量x

    print(id(x)) #打印变量x的标识

    print(x+5) #使用变量

    print("=========华丽的分割线=========")

    x = 2 #量赋值定义一个变量x

    print(id(x)) #此时的变量x已经是一个新的变量

    print(x+5) #名称相同,但是使用的是新的变量x

    继续赋值

    x = 'hello python'

    print(id(x))

    print(x)

    此时x又将成为一个新的变量,而且变量类型也由于所赋值的数据类型改变而改变。

    此处,id()为Python的内置函数。参见:https://docs.python.org/3/library/functions.html#id

    如果变量没有赋值,Python将认为该变量不存在。

    Python支持多个变量同时赋值。

    例如:

    a = (1,2,3) #定义一个序列

    x,y,z = a #把序列的值分别赋x、y、z

    print("a : %d, b: %d, z:%d"%(x,y,z)) #打印结果

    a, b, c = 1, 2, "john"

    变量作用域

    局部变量是只能在函数或者代码块内使用的变量,函数或者代码块一旦结束,局部变量的生命周期也将结束。局部变量的作用范围只有在局部变量被创建的函数内有效。

    例如:在文件1中的fun()中定义了一个局部变量,则该局部变量只能被fun()访问,文件1中定义的fun2()不能访问,也不能被文件2访问。

    #fileName:file1

    def fun():

    local_var = 100 #定义一个局部变量

    print(local_var)

    def fun2():

    zero = local_var - 100 #fun2中使用局部变量(不可以)

    print("get zero : %d"%zero)

    fun()

    #fun2()

    print("local_var -1 = %d"%(local_var - 1)) #文件1中使用局部变量(不可以)

    ################################

    #Traceback (most recent call last):

    # File "E:/python/file1.py", line 10, in

    # print("local_var -1 = %d"%(local_var - 1))

    #NameError: name 'local_var' is not defined

    ################################

    #Traceback (most recent call last):

    # File "E:/python/file1.py", line 9, in

    # fun2()

    # File "E:/lichenli/python/file1.py", line 6, in fun2

    # zero = local_var - 100

    #NameError: name 'local_var' is not defined

    ################################

    #fileName:file2

    import file1

    file1.fun()

    print(local_var)

    ########################

    #运行结果

    #100

    #Traceback (most recent call last):

    # File "E:\python\file2.py", line 4, in

    # print(local_var)

    #NameError: name 'local_var' is not defined

    ########################

    fun()中定义的局部变量就只有fun能够访问。

    全局变量是能够被不同函数、类或文件共享的变量,在函数之外定义的变量都叫做全局变量。全局变量可以被文件内任何函数和外部文件访问。

    #fileName:file1

    g_num1 = 1 #定义全局变量

    g_num2 = 2 #定义全局变量

    def add_num():

    global g_num1 #引用全局变量

    g_num1 = 3 #修改全局变量的值

    result = g_num1 + 1

    print("result : %d"%result)

    def sub_num():

    global g_num2

    g_num2 = 5

    result = g_num2 - 3

    print("result : %d"%result)

    add_num()

    sub_num()

    print("g_num1:%d "%g_num1)

    print("g_num2:%d "%g_num2)

    #result : 4 result为局部变量

    #result : 2

    #g_num1:3 全局变量g_num1在执行add_num()函数时被改变

    #g_num2:5 全局变量g_num2在执行sub_num()函数时被改变

    global保留字用于引用全局变量,如果不适用global关键字,在函数中再为g_num1赋值时将被解释为定义了一个局部变量g_num1。

    #添加到sub_num()函数定义之后,add_num()函数调用之前

    def other():

    result = g_num1 + 2 #直接适用全局变量不改变全局变量的值OK

    print("result : %d"%result)

    other()

    #######################

    #result : 3

    #result : 4

    #result : 2

    #g_num1:3

    #g_num2:5

    #######################

    #添加到sub_num()函数定义之后,add_num()函数调用之前

    def other():

    g_num1 = 10

    result = g_num1 + 2

    print("result : %d"%result)

    other()

    ####################

    #result : 12

    #result : 4

    #result : 2

    #g_num1:3

    #g_num2:5

    ####################

    在文件2中访问全局变量。

    #fileName:file2

    import file1

    file1.add_num() #g_num1被改变

    test = file1.g_num1 + 1

    print("test :%d"%test)

    应该尽量避免使用全局变量。不同的模块可以自由的访问全局变量,可能会导致全局变量的不可预知性。

    全局变量降低了函数或者模块之间的通用性,不同的函数或模块都要依赖于全局变量。同样,全局变量降低了代码的可读性,阅读者可能不知道调用的某个变量是全局变量。

    常量

    常量是一旦初始化之后就不能修改的固定值。例如:数字"5",字符串"abc"都是常量。

    Python中并没有提供定义常量的保留字。Python是一门功能强大的语言,可以自己定义一个常量类来实现常量的功能。

    #fileName:const.py

    class _const:

    class ConstError(TypeError):pass

    def __setattr__(self,name,value):

    #if self.__dict__.has_key(name): 3.x之后has_key被废弃

    if name in self.__dict__:

    raise self.ConstError("Can't rebind const(%s)"%name)

    self.__dict__[name] = value

    import sys

    sys.modules[__name__] = _const()

    #fileName:const_2.py

    import const

    const.name='zhangsan'

    const.name='lisi'

    ##################################

    #Traceback (most recent call last):

    # File "E:/python/const_2.py", line 4, in

    # const.name='lisi'

    # File "E:/python\const.py", line 7, in __setattr__

    # raise self.ConstError("Can't rebind const(%s)"%name)

    #const._const.ConstError: Can't rebind const(name)

    ##################################

    name这个变量已经被赋值"zhangsan"不能继续被赋值,所以抛出异常。raise保留字用于抛出异常。

    以上这篇深入理解Python变量与常量就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持脚本之家。

    展开全文
  • c++中的字符串常量为什么可以赋值给char*? 比如可以写一下代码:char*str="hello";其中的"hello"不是const char*类型吗?为什么可以给char*赋值? 1. C中"hello"类型是char[6],所以允许char* ...

    http://www.zhihu.com/question/20362192

     

    c++中的字符串常量为什么可以赋值给char*?

    比如可以写一下代码:
    char*str="hello";
    其中的"hello"不是const char*类型吗?为什么可以给char*赋值?

    1.

     
    C中"hello"类型是char[6],所以允许char* str="hello"; 你甚至可以接着使用 *str = "d" 这样赋值,编译通过没问题只不过会在运行时报错,因为"hello"位于只读存储区不允许写操作。
    C++中"hello"的类型是const char[6],不过为了兼容C代码做了特殊处理,所以也允许赋值给char*指针。
     

    2.

     
    "hello" 在这里是一个地址, char * 类型指向一个地址的话,没有问题, 至于地址的内容能否修改是另一回事 

    3.

    决定权在你, 这只是一个地址, 对于c来说, 这完全没问题, 但是你如果修改这个串的话, 就直接猝死.
    对于c++来说, 编译器可能会做隐式转换, 但仍然会给你一个友情提示. 总而言之, 不要过份依赖编译器.
    认真关注每一个警告.

    转载于:https://www.cnblogs.com/buxianghe/archive/2013/04/22/3036675.html

    展开全文
  • 如: [code="java"]short s = 3;[/code] 3不是int型吗
  • 字符串常量池(String类型为什么可以直接赋值?就和它有关) String类是我们平常项目中使用频率非常高的一种对象类型,jvm为了提升性能和减少内存开销,避免字符的重复创建,其维护了一块特殊的内存空间,即字符串池...

    首先明白一个事,java存在一个常量池,可以用来存储字符串常量。

    字符串常量池(String类型为什么可以直接赋值?就和它有关)


    String类是我们平常项目中使用频率非常高的一种对象类型,jvm为了提升性能和减少内存开销,避免字符的重复创建,其维护了一块特殊的内存空间,即字符串池,当需要使用字符串时,先去字符串池中查看该字符串是否已经存在,如果存在,则可以直接使用,如果不存在,初始化,并将该字符串放入字符创常量池中。

    使用new String赋值不可以吗?可以,但是我们不开发中不建议用new String()的方式去创建字符串,原因如下:

    两种创建方法的区别:

    1. String str1= “abc”; 在编译期,JVM会去常量池来查找是否存在“abc”,如果不存在,就在常量池中开辟一个空间来存储“abc”;如果存在,就不用新开辟空间。然后在栈内存中开辟一个名字为str1的空间,来存储“abc”在常量池中的地址值。

    2. String str2 = new String("abc") ;在编译阶段JVM先去常量池中查找是否存在“abc”,如果过不存在,则在常量池中开辟一个空间存储“abc”。在运行时期,通过String类的构造器在堆内存中new了一个空间,然后将String池中的“abc”复制一份存放到该堆空间中,在栈中开辟名字为str2的空间,存放堆中new出来的这个String对象的地址值。

    也就是说,前者在初始化的时候可能创建了一个对象,也可能一个对象也没有创建;后者因为new关键字,至少在内存中创建了一个对象,也有可能是两个对象。
     

    分别举例:

    1.使用String直接赋值

    String str = “abc”;可能创建一个或者不创建对象,如果”abc”在字符串池中不存在,会在java字符串池中创建一个String对象(”abc”),然后str指向这个内存地址,无论以后用这种方式创建多少个值为”abc”的字符串对象,始终只有一个内存地址被分配。==判断的是对象的内存地址,而equals判断的是对象内容。通过以下代码测试:

    String str = "abc";
    String str1 = "abc";
    String str2 = "abc";
    System.out.println(str==str1);//true
    System.out.println(str==str2);//true

    也就是str、str1、str2都是指向同一个内存地址。

    2.使用new String()赋值

    String str = new String(“abc”);至少会创建一个对象,也有可能创建两个。因为用到new关键字,肯定会在堆中创建一个String对象,如果字符池中已经存在”abc”,则不会在字符串池中创建一个String对象,如果不存在,则会在字符串常量池中也创建一个对象。

    String str = new String("abc");
    String str1 = new String("abc");
    String str2 = new String("abc");
    System.out.println(str==str1);//false
    System.out.println(str==str2);//false

    可以看出来,str、str1、str2指向的是不同的内存地址。

    原因归纳:

    上文可以归纳出:直接赋值产生1或0个对象,使用new String()赋值时产生2或1对象,赋值时先看字符串常量池,如果字符串常量池中没有,就在常量池中创建一个,如果有,前者直接引用,后者在堆内存中还需创建一个“abc”实例对象(此时引用变量指向的是堆内存中创建的实例对象,而不是常量池中的实例对象)。

    String类被设计成不可变(immutable)类,所以它的所有对象都是不可变对象。例如:       

    String str = “hello";

    str = str + "world“;

    当上文str指向了一个String对象(内容为“hello”),然后对str进行 “+” 操作,str原来指向的对象并没有变(依然存在在常量池中),而是str此时又指向了另外一个对象(“hello world”),原来的对象还在内存中。

    由此可以看出,频繁的对String对象进行修改,会造成很大的内存开销。此时应该用StringBuffer或StringBuilder来代替String。

    所以使用new String() 方式赋值更不适合,因为每一次创建对象都会调用构造器在堆中产生新的对象,性能低下且内存更加浪费。

    额外说明(字很多,但这是知识的丰富):

    使用String拼接字符串

    项目中除了直接使用=赋值,也会用到字符串拼接,字符串拼接又分为变量拼接和已知字符串拼接。

    String str = "abc";//在常量池中创建abc
    String str1 = "abcd";//在常量池中创建abcd
    String str2 = str+"d";//拼接字符串,此时会在堆中新建一个abcd的对象,因为str2编译之前是未知的
    String str3 = "abc"+"d";//拼接之后str3还是abcd,所以还是会指向字符串常量池的内存地址
    System.out.println(str1==str2);//false
    System.out.println(str1==str3);//true

    解答问题:为什么给str3赋值时不会在堆中创建一个对象,而给str2赋值时却会在堆中创建一个对象?

    首先你要明白java编译器和运行期和String原理。

    编译期:   是指把源码交给编译器编译成计算机可以执行的文件的过程。在Java中也就是把Java代码编成class文件的过程.编译期只是做了一些翻译功能,并没有把代码放在内存中运行起来,而只是把代码当成文本进行操作,比如检查错误。
     

    运行期:  是把编译后的文件交给计算机执行.直到程序运行结束。所谓运行期就把在磁盘中的代码放到内存中执行起来。在Java中把磁盘中的代码放到内存中就是类加载过程。

    比如通过String str = "aaa"赋值,字面量形式创建的字符串对象 "aaa" 存进了字符串常量池,而通过String str = String("bbb") 赋值,new 创建的 "bbb" 则是存进了堆中。这两种方式我们在代码编写时都经常使用,尤其是字面量的方式。然而这两种实现其实存在着一些性能和内存占用的差别。这一切都是源于JVM为了减少字符串对象的重复创建,其维护了一个特殊的内存,这段内存被成为字符串常量池或者字符串字面量池。

    String工作原理:当代码中出现字面量形式创建字符串对象时,JVM首先会对这个字面量进行检查。如果字符串常量池中存在相同内容的字符串对象的引用,则将这个引用返回。如果没有则创建新的字符串对象,然后将这个引用放入字符串常量池,并返回该引用。

    上面的概念比较笼统,其实就是啥意思呢?在编译时,如果碰到了String s = "hello"; 这样的赋值方式,就是字面量形式赋值,编译时就直接编译成 String s = "hello"; ,然后拿到内存中时就按照上述所说的直接赋值的那种方式去赋值,str3 = "abc" + "d"其实就等同于字面量赋值(即等同于str3 = "abcd")。但是,如果是str2这种赋值方式String str2 = str + "d"; ,虽然str在上面已经定义了,但是在编译时认为str仍是一个引用类型变量,所以此时就会把str2认为是以new String()方式来创建的,等来到内存中呢,就按照new String()这种方式去创建str2,自然堆内存中就会开辟空间,然后创建对象,接着再把空间的地址值返回给str2。所以str1和str2并没有指向同一个对象,地址值自然不同,这同时也解释了提出的问题。

    下面在附上一个测试的例子,来更好的帮助你理解String和new String():

    public class StringBy
    
    {
    
        public static void main(String[] args){
    
        //情况一
    
        String a = "a2";
    
        String a2 = "a"+2;
    
        //在编译期值是确定的就是a2。只有编译期变量a与变量a2值相等他们才相等
    
        System.out.println(a==a2);
    
        //情况二
    
        String b = "b2";
    
        int bb = 2;
    
        String b2="b"+bb;
    
       //在编译期变量b2的值不是确定的,因为bb是变量,变量在运行期才能确定值.所以b与b2不等
    
        System.out.println(b==b2);
    
        //情况三
    
        String c="c2";
    
        final int cc=2;
    
        String c2="c"+cc;//在编译期c2的值是确定的,因为cc是个常量,值为2
    
        System.out.println(c==c2);
    
        //情况四
    
        String d="d2";
    
        final int dd=getZ();
    
        String d2="d"+dd;
    
        //在编译器d2的值是不确定的,因为dd还没有确定,因为dd的值是靠方法返回来的,但是方法的结果是在            
        //运行期才能得到的
    
        System.out.println(d==d2);//(对于两个对象,==的作用是比较他们的地址。)
    
        }
    
        public static int getZ(){
    
            return 2;
    
        }
    
    }

    参考链接:

    https://www.cnblogs.com/lgg20/p/12521117.html

    https://blog.csdn.net/weixin_41098980/article/details/80060200

    https://jingyan.baidu.com/article/17bd8e521583f985ab2bb88a.html

    展开全文
  • Python3 常量与变量阅读 (123) |发布于 2020-05-11 18:43:47变量:在程序运行过程中,值会发生变化的量常量:在程序运行过程中,值不会发生变化的量无论是变量还是常量,在创建时都会在内存中开辟一块空间,用于保存...
  • C/C++:const常量真的可以用指针修改吗 常量在程序运行前就已经存在,并在程序运行时加载到常量区。 若定义常量a并赋值,之后使用指针p修改a的值。此时即使对a做任何计算,a的值还是未修改的值,但是*p的值会是...
  • 一、学习目标了解C语言的结构体的使用方法了解C语言结构体的结构的赋值了解多种C语言结构体变量的赋值方法和取值方法目录《零基础看得懂的C语言入门教程》——(二)简单带你了解流程 《零基础看得懂的C语言入门教程》...
  • 一、常量常量就是一个固定不变的量(或者值)已知的值。比如整数常量:23,122;小数常量:3.14;字符常量:'a';布尔常量:true,false;字符串常量:"你好"。...1.语法:先定义在赋值:数据类型 变量名;变量...
  • 操作符'='应该返回常量

    千次阅读 2006-12-11 17:26:00
    string::operator = 返回了一个引用,所以上面的链式赋值可以进行了。等价于x = (y = (z = "hello"));string::operator = 返回值是string &, 为什么不是 const string & ?这样可以防止 (x = y) = z;
  • 写在前面 字符串常量和字符数组,平时极易遇到的问题。...这两种方式都可以给字符数组赋值。一种使用字符串常量,一种用的单个字符赋值。但实际上,a偷偷带了一个小尾巴’\0’,这是因为字符串常量总是以’\...
  • 关于py中缺省参数:在声明函数的时候对某些参数(一个或多个)进行赋值,在你调用的时候无需在实参列表中体现该参数,但是在执行的时候会默认加上这个已经在形参中定义好的参数。 但是,缺省参数必须放在最后,缺省...
  • 数组和数组之间能直接赋值吗?——不能 你难道是想 a=b?? 首先你要明白: 数组名a,b代表指针常量,所以说赋值号左边必须是一个变量 a=b; 根本就是错误的 注意:数组名是常量,指针一般都是变量,当然也可以常量。...
  • C语言中const关键字是constant的缩写,通常翻译为常量、常数等,有些朋友一看到const关键字马上就想到了常量。事实上在C语言中const功能很强大,它可以修饰变量、数组、指针、函数参数等。本文将针对上述几种修饰...
  • 常量与变量的区别

    千次阅读 2018-06-19 15:20:04
    通过前面一系列的学习了解了PHP的常量和变量,那么你们知道PHP常量与变量有什么关系和区别吗?别急,下面就带着大家看看php常量与变量的关系和区别再来...我们可以在定义变量的时候对其赋值,如果需要改动变量的值...
  • 而指针在定义的时候不必初始化,可以在定义后面的任何地方重新赋值. (2) 不存在NULL引用,引用必须与合法的存储单元关联;而指针则可以是NULL. (3) 引用一旦被初始化为指向一个对象,它就不能被改变为另一个...
  • 静态变量和常量的区别

    万次阅读 2017-03-25 22:55:58
    共同点: 1、static和const在编译时直接分配内存...3、(赋值)静态变量的值在运行时可以更改赋值,而常量的值是不可改变的,运行一开始已经固定,之后修改会报错。 4、(内存)静态变量存放在全局数据区中,伴随着这
  • 简单的说,可变(mutable)意味着"可以被改动",而不可变(immutable)的意思是“常量(constant)”。想把脑筋转动起来吗?考虑下这个例子: foo = ['hi'] print(foo) # Output: ['hi'] bar = foo bar
  • 共同点 1、static和const在编译时直接分配内存 区别 1、(本质)static是类型引用,const... 3、(赋值)静态变量的值在运行时可以更改赋值,而常量的值是不可改变的,运行一开始已经固定,之后修改会报错。 ...
  • var c = a + b //把a与b的和赋值给c常量与变量适合在什么时候使用呢?当代吗中,如果储存的值不会做出改变,使用let,如果要改变,就使用var2、类型标注在申明常量或变量的时候可以申明类型,来明确...
  • 而指针在定义的时候不必初始化,可以在定义后面的任何地方重新赋值。(2) 不存在NULL引用,引用必须与合法的存储单元关联;而指针则可以是NULL。(3) 引用一旦被初始化为指向一个对象,它就不能被改变为另一个对象的...
  • 常量池中如果已经存在某一个字符串了(如"java"),那么再新建一个变量,为它赋值为"java",那么这个变量是不是指向之前已经存在的那个"java"的地址?这样如果常量池中有很多常量,每次新建时程序都要去常量池挨个...
  • C++字符串常量跨平台编译问题(与字符串编码相关),有需要的朋友可以参考下。 1. 问题 在C++代码中,给一个string类型的变量赋值一个中文字符串常量,例如: string s = "中文字符串" 变量s中保存的字节内容是什么?...
  • 注意,需要说明的一点是自PHP4以来,引入了引用赋值的概念,其实和多数语言的引用类似,不过我觉得最类似的是C/C++.因为它也用到了"&"符号。例如:和其他语言一样,只能对有变量名的变量才可以引用。好了现在大家对...
  • 2.给变量赋值 3.使用变量 变量的声明,赋值 int a; //将要放的物品告诉家长 a=50;//将物品放到某个抽屉中 声明变量的语法格式 1.数据类型 变量名; 赋值:变量名=值; 可以a=3.14;吗?? 不可以,...
  • 可以,因为String类有final修饰符,而final修饰的类是不能被继承的,实现细节不允许改变。 关于final修饰符,介绍如下: 根据程序上下文环境,Java关键字... final成员变量表示常量,只能被赋值一次,赋值后值不再改
  • 前言一年前刚毕业面试的时候,有次聊到ES6新特性,我首先提到的是新的变量声明:有自带...我脱口而出的是可以修改,但是解释起来却卡了壳,浅浅地说了说JS中的基本类型和引用类型,现在想来确实有些惭愧。基本类型&...
  • 可以用于修饰类、方法和变量。不能被继承 概述: 类 :被修饰的类,不能被继承。 方法:被修饰的方法,不能被被重写。 变量:被修饰的变量,就只能赋值一次,不能被重新赋值。 //被final修饰的常量名称,一般都有书写规范,...

空空如也

空空如也

1 2 3 4 5 ... 7
收藏数 137
精华内容 54
关键字:

常量可以赋值吗