精华内容
下载资源
问答
  • 一次函数变量与常量的概念
    千次阅读
    2021-01-20 21:16:03

     

    1、 常量

    常量指定的是在软件编程过程中不能给赋值且值不能被改变的量。一般包括数字、字符、字符串常量等。

    例如:整型常量:12、0、-3;

              实型常量:4.6、-1.23;

              字符常量:‘a’、‘b’。

              标识符:用来标识变量名、符号常量名、函数名、数组名、类型名、文件名的有效字符序列。

             符号常量:用标示符代表一个常量。在C语言中,可以用一个标识符来表示一个常量,称之为符号常量。

            符号常量在使用之前必须先定义,其一般形式为:

                     #define 标识符 常量

                     其中#define也是一条预处理命令(预处理命令都以"#"开头),称为宏定义命令(在后面预处理程序中将进一步介绍),其功能是把该标识符定义为其后的常量值。一经定义,以后在程序中所有出现该标识符的地方均代之以该常量值。

     

    2、 变量

    顾名思义就是在程序运行的时候可以给变的量称为变量,变量一般是我们在编写程序的时候自己定义的。

    定义方式如下:

    变量类型  变量名;

    变量类型指的是定义的变量的类型,一般变量的类型包括基本数据类型、指针类型、复杂类型等。

    变量名表示的是定义的变量的名称。

    一个变量应该有一个名字,在内存中占据一定的存储单元。变量定义必须放在变量使用之前。一般放在函数体的开头部分。要区分变量名和变量值是两个不同的概念。

    例如:

    int a;//表示定义一个int 型的变量a。

    a = 100;//表示对变量a的值进行给变,将其赋值为100.

    通过这两个语句我们就定义了一个变量a,变量a的值为100.

    其他类型的变量:

    char b;//char型变量b

    float c;//定义一个float类型的变量c

    变量根据作用域的不同分为全局变量和局部变量,全局变量也称为外部变量,它是在函数外部定义的变量。它不属于哪一个函数,它属于一个源程序文件。其作用域是整个源程序。 局部变量也称为内部变量。局部变量是在函数内作定义说明的。其作用域仅限于函数内, 离开该函数后再使用这种变量是非法的。

    变量类型

    变量范围

    局部变量

    局部变量的作用域是作用域是自变量定义到当前函数体结束。

    全部变量

    整个函数

    我们定义的变量都有一个生命周期和作用域,一般不同方式定义的变量的生命周期和作用域不一样。

    作用域指定但是变量的使用范围,不同的作用域可以定义相同名的变量。使用的时候有限使用离得最近的变量。不同作用域的相同名称的变量不会相互影响。

    生命周期指的是一个变量从创建到销毁的时间,称为生命周期。

     变量的定义形式作用域生命周期
    局部变量static修饰的局部变量一对{}内({}称为一个函数体)整个程序运行期间
    普通的局部变量一对{}内     ({}称为一个函数体)从变量的定义到当前函数运行完成
    全局变量 static修饰的全局变形量当前文件可以使用,其他文件使用extern声明也不能调用整个函数运行期间
    普通的全局变量整个项目可以使用(非当前文件需要使用extern声明)整个函数运行期间
     extern声明的变量整个项目文件都可以使用整个程序运行期间
     extern声明函数整个程序整个程序运行期间
     static修饰函数当前文件整个程序运行期间

    需要注意的是static修饰的局部变量只能初始化一次,但是可以进行多次赋值。
        

    变量数据类型的转换

    变量在传递值的过程中,有可能会在不同数据类型之间传递,这样的话就需要对数据类型进行转换。数据类型的转换方式有两种。

    1)隐式转换也称做自动转换(数据类型所占字节小于要转数据类型)

    例如:

    char ch = 'c';
    int a = ch;//这是将一个char类型的数据复制个一个int型的数据,这属于隐式转换
    
    
    double b = a;//将int型的a数据转化为double类型
    

    2)强制转换(大转小),强制转换的时候,一定要在转换的变量之前增加强制转换的数据类型。如一下例子需要在a变量之前增加char类型强制转换

    例如:

    int a = 100;
    char c = (char)a;//这是将一个int型的数据强制转换成char型,超出char型的数据将会丢失


      
      

    3、 函数

    1)函数的概念

    函数指的是一个程序的集合,专门用于实现某一个功能的代码块。在程序的编写中使用函数可以提高代码的可阅读性和增加代码的可维护性。

    从函数定义的角度看,函数可分为库函数和用户定义函数两种。库函数:由C系统提供,用户无须定义,也不必在程序中作类型说明,只需在程序前包含有该函数原型的头文件即可在程序中直接调用。用户定义函数:由用户按需要写的函数。对于用户自定义函数,不仅要在程序中定义函数本身,而且在主调函数模块中还必须对该被调函数进行类型说明,然后才能使用。

    根据函数的返回值和函数有无参数可以分为以下四种函数的形式。有参无返、有参有返、无参无返和无参有返。

    2)函数的定义

    定义函数需要注意两个方面,那就是函数的返回类型和函数参数的类型。我们所能定义和使用的变量类型都可以作为函数的返回值和函数参数的类型。

    例如:int、 float 、double、 long 、 数组、 结构体和枚举等多可以作为函数的返回值和参数。后面会陆续介绍。

    1 无参返函数的定义形式

        类型标识符 函数名()
       { 
            声明部分
           语句
        }

    其中类型标识符和函数名称为函数头。类型标识符指明了本函数的类型,函数的类型实际上是函数返回值的类型。 该类型标识符与前面介绍的各种说明符相同。函数名是由用户定义的标识符,函数名后有一个空括号,其中无参数,但括号不可少。{}中的内容称为函数体。在函数体中声明部分,是对函数体内部所用到的变量的类型说明。

    函数参数一般是通过return返回的。

      例如:

    
    int fun()
    {
        函数体;
        return 1;
    }

    此例子表示定义了一个有返无参的函数,返回值为int类型。

    2 有返有参函数定义的一般形式

     类型标识符 函数名(形式参数表列)
     { 
            声明部分
            语句
     }

    其中类型标识符和函数名称为函数头。类型标识符指明了本函数的类型,函数的类型实际上是函数返回值的类型。 该类型标识符与前面介绍的各种说明符相同。函数名是由用户定义的标识符,函数名后有一个括号。括号中的形式参数列表就是需要传递的参数{}中的内容称为函数体。在函数体中声明部分,是对函数体内部所用到的变量的类型说明。

    例如:

    int fun( int a,int b)
    {
        函数体;
        return 1;
    }

    此例子表示定义了一个有返有参的函数,返回值为int类型。参数列表为int a,int b。a和b的值是传递到函数中取的。

    3 无返有参函数定义的一般形式

       void 函数名(形式参数表列)
       { 
           声明部分
           语句
       }

     

    其中void 标识符指明了本函数的类型,本函数是一个返回为空类型的函数,因此本函数是没有返回指的。函数名是由用户定义的标识符,函数名后有一个空括号。其中无参数,但括号不可少。{}中的内容称为函数体。在函数体中声明部分,是对函数体内部所用到的变量的类型说明。

    例如:

    void fun( int a,int b)
    {
        函数体;
    }

    此例子表示定义了一个无返返有参的函数,返回值为void类型。参数列表为int a,int b。a和b的值是传递到函数中取的。

    4 无返无参函数定义的一般形式   

    void 函数名()
    { 
        声明部分
        语句
    }

     

    其中void 标识符指明了本函数的类型,本函数是一个返回为空类型的函数,因此本函数是没有返回指的。函数名是由用户定义的标识符,函数名后有一个空括号。其中无参数,但括号不可少。{}中的内容称为函数体。在函数体中声明部分,是对函数体内部所用到的变量的类型说明。这种函数一般用于对一些器件或者堆空进行初始化使用。

    例如:

    void fun()
    {
        函数体;
    }

    此例子表示定义了一个无返返有参的函数,返回值为void类型。

    需要注意的是如果调用的函数是有返函数,那么在函数体中必须要有一个return语句返回返回值。

    3)函数的调用

    在程序中是通过对函数的调用来执行函数体,其过程与其它语言的子程序调用相似。

    函数调用的一般形式为:

        函数名(实际参数表);

    对无参函数调用时则无实际参数表。实际参数表中的参数可以是常数,变量或其它构造类型数据及表达式。各实参之间用逗号分隔。

    在主调函数中调用某函数之前应对该被调函数进行说明(声明),这与使用变量之前要先进行变量说明是一样的。在主调函数中对被调函数作说明的目的是使编译系统知道被调函数返回值的类型,以便在主调函数中按此种类型对返回值作相应的处理。

    其一般形式为:

            类型说明符 被调函数名(类型 形参,类型 形参…);  

    或为:

            类型说明符 被调函数名(类型,类型…);  

    括号内给出了形参的类型和形参名,或只给出形参类型。这便于编译系统进行检错,以防止可能出现的错误。

    例: main函数中对max函数的说明为:

            int max(int a,int b);

    或写为:

            int max(int,int);

    但是有以下几个情况需要对函数进行声明:

    A、如果被调函数的返回值是整型或字符型时,可以不对被调函数作说明,而直接调用。这时系统将自动对被调函数返回值按整型处理。

    B、当被调函数的函数定义出现在主调函数之前时,在主调函数中也可以不对被调函数再作说明而直接调用。

    C、如在所有函数定义之前,在函数外预先说明了各个函数的类型,则在以后的各主调函数中,可不再对被调函数作说明。

     

    在C语言中,可以用以下几种方式调用函数:

    A、函数直接作为表达式进行调用,这种函数一般都是针对有返回值的函数的一种调用方式。例如 :int a = fun(a,b);fun函数是一个有返回值的函数,返回值为int类型。

    B、函数语句是直接将调用的函数当成一个语句进行适应,这种方式是用于没有返回值的函数。例如:fun(a,b);fun函数是一个没有返回值的函数。

    C、函数也可以当做另一个函数的实参进行使用。但是这种调用方式和第一种一样都是针对有返回值的函数进行调用的。例如:fun(fun1(a,b),c);fun1是一个又返回值的函数。

    D、对库函数的调用不需要再作说明,但必须把该函数的头文件用include命令包含在源文件前部。

     

    4)函数嵌套调用函数

    C语言中不允许作嵌套的函数定义。因此各函数之间是平行的,不存在上一级函数和下一级函数的问题。但是C语言允许在一个函数的定义中出现对另一个函数的调用。这样就出现了函数的嵌套调用。即在被调函数中又调用其它函数

    例如:

    
    fun()
    {
        ……
        fun1(a,b);//调用函数fun1
        ……
    }
    
    fun1(int a,int b)
    {
            ……
         fun2();//调用函数fun2
            ……
    }
    
    fun2()
    {
        函数体;
    }

    以上例子就是一个函数嵌套调用的例子,首先函数fun()调用fun1(int a,int b)函数。而fun1(int a,int b)函数有调用fun2()函数。

    4)函数递归调用函数

    一个函数在它的函数体内调用它自身称为递归调用。这种函数称为递归函数。C语言允许函数的递归调用。在递归调用中,主调函数又是被调函数。执行递归函数将反复调用其自身,每调用一次就进入新的一层。

    例如有函数f如下:

    int fun(int x)
    {
          int y;
          z=fun(y);//递归调用函数
          return z;
    }

    这个函数是一个递归函数。但是运行该函数将无休止地调用其自身,这当然是不正确的。为了防止递归调用无终止地进行,必须在函数内有终止递归调用的手段。常用的办法是加条件判断,满足某种条件后就不再作递归调用,然后逐层返回。下面举例说明递归调用的执行过程。

    需要注意的是如果使用递归调用函数,如果没有函数出口,那么可能会造成内存的溢出导致软件崩溃。

     

    更多相关内容
  • 变量是计算机内存中的一块区域,变量可以存储规定范围内的值,... Python中一次新的赋值,将创建一个新的变量。即使变量的名称相同,变量的标识并不同。 x = 1 #变量赋值定义一个变量x print(id(x)) #打印变量x的标识
  • 2018年秋八年级数学上册第5章一次函数5.1常量与变量练习新版浙教版
  • Golang_变量常量详解

    千次阅读 2022-01-22 11:55:58
    在编码阶段我们用个易于阅读的名字来表示这段内存,称为变量名。 而变量名只是为了让我们开发者更好的查找和使用,实际上编译后的机器码从不使用变量名,而是通过内存地址来访问目标数据。......

    变量:

    变量是在程序运行过程中,其值可以发生改变的数据,作为静态类型语言,Go变量有固定的数据类型,类型决定了变量内存的长度和存储格式。我们只能修改变量值,无法改变类型。

    局部变量&全局变量:

    • 定义函数内部的变量称为局部变量,局部变量的作用域在函数的内部
    • 定义函数外部的变量称为全局变量,全局变量的是任何函数都可以使用
    • 如果全局变量和局部变量的名字相同,在函数内使用时局部变量的优先级大于全局变量,采用就近原则,

    变量名:

    因为内存分配发生在运行期,所以在编码阶段我们用一个易于阅读的名字来表示这段内存,称为变量名。 而变量名只是为了让我们开发者更好的查找和使用,实际上编译后的机器码从不使用变量名,而是通过内存地址来访问目标数据。

    命名规则:

    • 优先选用有实际含义,易于阅读和理解的字母、单词或组合对变量、常量、函数、 自定义类型进行命名(如下方代码所示)

    • 以字母或下划线开头,由字母、数字和下划线组成,且区分大小写(name、Name、NAME是三个变量)

    • 使用驼峰式命名,名字首字母大小写决定了其作用域,首字母大写(public)可以被外部引用,而小写(private)则仅能在包内使用

    • 局部变量优先使用短命名

    • 专有名词通常会全部大写,例如escapeHTML

    	var c int                 // c代替count
    	for i := 0; i < 10; i++ { // i代替index
    		c++
    	}
    

    变量的定义:

    关键字var用于定义变量,数据类型被放在变量名后。另外,运行时内存分配操作会确保变量自动初始化为二进制零值(zero value),避免出现不可预测行为。如果是显式初始化变量,可省略变量类型,由编译器推断具体的数据类型。

    func variable() {
    	var x int  		   // 定义x	没初始化	默认值0
    	var y = 1  		   // 定义y	有初始化	数据类型int  将1赋值给y
    	var z bool       // 定义z	没初始化	默认值为false
    	var a int				 // 先定义a
    	a = 1						 // 然后把1再赋值给a
    	fmt.Println(x, y, z, a)
    }
    

    可以一次性定义多个变量:

    func variable02() {
    	var x, y int               // 多个变量相同数据类型
    	var n, m = 100, "itzhuzhu" // 多个变量不同数据类型
    	fmt.Println(x, y, n, m)
    }
    

    多个变量以组的方式定义:

    func variable03() {
    	var (
    		x, y int               // 多个变量相同数据类型
    		n, m = 100, "itzhuzhu" // 多个变量不同数据类型
    	)
    	fmt.Println(x, y, n, m)
    }
    

    自动推导类型:

    在给变量赋值时,可以简化书写,使用:代替var,会根据所赋的值的自动检测类型

    func variable04() {
    	w := 1
    	x, y, z := 2.3, 4, "itzhuzhu"
    	fmt.Println(w, x, y, z)
    }
    

    自动推导类型解析,如果全局变量使用自动推导类型定义会报错,可以定义全局变量,但是不能在函数外先定义再赋值,语法违规

    	Name:="itzhuzhu" // 报错,语法违规
      func main (){}
    
    ——————————————————————————————————————————自动推导类型等于下面两步的合体——————————————————————————————————————————
    	var x int // 1、先定义x为int类型
    	x = 1 // 2、再为x赋值,但是上面已有
    

    自动推导类型的弊端:

    • 定义变量同时要显式初始化
    • 不能自定义数据类型
    • 自动推导类型创建的变量是局部变量,只能在同一个作用域下被调用
    var x = 1            // 定义全局变量
    
    func main() {
    	fmt.Println(&x, x) // 全局变量
    
    	var x = "局部变量" // 局部变量
    	fmt.Println(&x, x)
    }
    

    输出:

    0x10425c288 1
    0x14000010070 局部变量
    

    自动推导类型重新赋值操作,前提是有新的变量且在同一个作用域

    func variable05() {
    	x := 1
    	println(&x)
    
    	x, y := 2, "abc" // x在这里是重新赋值   y是定义新变量
    	println(&x, x, y)
    }
    

    打印结果:

    0x14000096f60
    0x14000096f60 2 abc
    

    没有新的变量

    func variable06() {
       x := 1
       println(&x)
    
       x := 2 // 报错:':=' 的左侧没有新变量
       println(&x, x)
    }
    

    有新的变量但不在同一个作用域将作为新变量定义

    func variable07() {
    	x := 1
    	println(&x)
    
    	{
    		x, y := 1, 2 // 这里的x和上面的x已经是不同作用域了,x,y全部视为定义新变量
    		println(&x, x, y)
    	}
    }
    

    输出:

    0x14000064f60
    0x14000064f58 1 2
    

    多变量赋值:

    在进行多变量赋值操作时,首先计算出所有右值,然后依次完成赋值操作,但必须保证左右值的数据类型相同

    func variable08() {
    	x, y := 1, 2    // x:1  y:2
    	x, y = y+3, x+2 // 先计算出右值y+3、x+2,然后再把结果赋值给左边的x、y变量
    	fmt.Println(y)
    }
    

    变量值交换:

    func variat09() {
    	var a = 1
    	var b = 2
    	var c int    // 定义第3个变量
    	c = a				 // 把a的值给c
    	a = b				 // 把b的值给a
    	b = c				 // 把c的值给b
    	fmt.Println(a, b)
    }
    
    // 也可以使用自动推导类型赋值的方式交换变量值
    func variate10() {
    	var a = 1
    	var b = 2
    	a, b = b, a
    	fmt.Println(a, b)
    }
    

    忽略占位符_解决未使用报错:

    Go有个名为的特殊成员(Black Identifier)。通常作为忽略占位符使用,可作表达式左值,无法读取其内容。使用_表示,空标识符可用来临时规避编译器对未使用变量和导入包的错误检查

    通常定义变量后未被使用编译器就会报错,使用此方法可以规避

    import (
    	"fmt"
    	_"os"	// 对于还没用到且不想删除的可以加上占位符,避免编译报错
    )
    
    	_, err = conn.Write([]byte(fileName))	// _:表示忽略占位符
    	if err != nil {
    		fmt.Println("conn.Write err:", err)
    		return
    }
    

    常量:

    常量是在程序运行过程中,其值不可以发生改变的数据。常量的定义是通过const关键字完成的,并且常量名称要大写
    常量值必须是编译期可确定的字符、字符串、数字或布尔值。可指定常量类型或由编译 器通过初始化值推断。常量无法被获取地址。

    常量除不可以再次赋值外,和变量究竟有什么不同?

    常量不会分配存储空间,无需像变量那样通过内存寻址来取值,因此无法获取地址。
    常量值不能再次改变,变量可以

    // 当常量比较多的时候可以使用常量块来表示,比较简洁
    const (
    	USERNAME = "itzhuzhu"
    	AGE      = 24
    	ADDRESS  = "广州"
    )
    
    // 也可以多重赋值
    const GENDER, HOBBY = "男", "黑丝"
    
    func main() {
    	const USERNAME string = "itzhuzhu2"
    	fmt.Println(USERNAME, AGE, ADDRESS) // 就近原则打印的是itzhuzhu2
    	fmt.Println(&USERNAME) //报错:无法提取常量地址
    }
    

    定义常量不使用不会编译错误,不同作用域也可以定义相同常量

    func constant() {
    	const X = 123
    	fmt.Println("我是外面的:", X)
    	const Y = 1.23 //	未使用不会引发编译错误
    	{
    		const X = 321 //	不同作用域定义同名常量
    		fmt.Println("我是里面的:", X)
    	}
    }
    

    常量值也可以是某些编译器能直接计算结果的表达式,如unsafe.Sizeof、len、cap等

    func constant02() {
    	const (
    		ptrSize = unsafe.Sizeof(uintptr(0)) // 函数返回操作数在内存中的字节大小
    		strSize = len("hello, world!")
    	)
    	fmt.Println(ptrSize)
    	fmt.Println(strSize)
    }
    

    在常量组中如不指定类型和初始化值,则与上一行非空常量右值(或表达式文本)相同。

    func constant04() {
    	const (
    		X uint16 = 120
    		Y        // 与上一行x类型、右值相同
    		S = "abc"
    		Z        // 与s类型、右值相同
    	)
    	fmt.Printf("%T, %v\n", Y, Y) // 输出类型和值
    	fmt.Printf("%T, %v\n", Z, Z)
    }
    

    打印结果:

    uint16, 120
    string, abc
    

    显示常量和隐式定义常量区别:

    const x = 100     // 隐式无常量类型,值随便写
    const y byte = x  // 相当于const y byte = 100
    const a int = 100 // 显式指定常量类型,编译器会做强类型検查
    const b byte = a  // 错误:cannot use a (type int) as type byte in const initializer
    

    展开全文
  • C语言中的变量与常量

    千次阅读 2020-05-24 14:40:55
    变量与常量 1.变量与常量   在整个程序的运行过程中,没有变化且不能变化的,我们称之为常量。在程序运行期间,可能会改变或者被赋值的,我们称之为变量。 2.声明变量   在前面的几章中,我们已经看过如何...

    变量与常量

    1.变量与常量

      在整个程序的运行过程中,没有变化且不能变化的,我们称之为常量。在程序运行期间,可能会改变或者被赋值的,我们称之为变量。

    2.声明一个变量

      在前面的几章中,我们已经看过如何声明一个变量了。

    short s;
    int n;
    long l;
    float f;
    double d;
    

      声明变量的公式:类型 + 标识符 + 封号

      即可声明一个变量。

      必须先声明变量后,才能使用变量。

    正确, 变量使用前被声明了。

    //  正确
    #include <stdio.h>
    int main()
    {
        int a;
        printf("%d\n", a); //  正确, 变量使用前被声明了。
        return 0;
    }
    

    错误, 变量a未声明。

    //  错误
    #include <stdio.h>
    int main()
    {
        printf("%d\n", a); //  错误, 变量未声明。
        return 0;
    }
    

    错误, 变量a在声明前使用。

    //  错误
    #include <stdio.h>
    int main()
    {
        printf("%d\n", a); //  错误, 变量在声明前使用。
        int a;
        return 0;
    }
    

    3. 变量允许使用的字符

      声明变量的公式:类型 + 标识符 + 封号

      标识符由大小写字母,数字和下划线组成。标识符不能以数字开头,并且必须与现有的关键词不同。

    short apple; 正确
    int 88fruit; 错误,不能以数字开头
    long _pencil; 正确,可以以下换线或字母开头
    float love_you; 正确,字母开头,标识符可以使用下划线
    double int; 错误,不能与现有关键词相同
    

    TIPS:

      关键词是被编译器识别的,具有特殊意义的单词。在C语言标准中,关键词如下表所示。它们在C语言当中,都有具体的语法意义。例如int,代表一个整型数据类型,return代表函数结束并带回返回值。

    auto_Bool*breakcase
    char_Complex*constcontinue
    defaultrestrict*dodouble
    elseenumexternfloat
    forgotoif_Imaginary*
    inline*intlongregister
    returnshortsignedsizeof
    staticstructswitchtypedef
    unionunsignedvoidvolatile
    while


    4. 变量初始化和赋值

      我们思考一下,下面的代码,它的打印出来的数值是多少呢?

    #include <stdio.h>
    int main()
    {
        int a;
        printf("%d\n", a);
        return 0;
    }
    

      我们发现,它居然报错了!

    uninit

      这段代码,在Visual Studio 2019中这段代码已经无法编译成功了。为什么呢?因为a没有被初始化,也没有被赋值。它的值是一个随机值。这样很危险,有可能导致程序产生错误的结果。因此,在Visual Studio 2019中已经禁止使用了。早期的版本你可以看到a的值是一个无意义的随机值。

      以下两种是正确的写法

      写法1:变量声明后,立刻初始化为100。

    #include <stdio.h>
    int main()
    {
        int a = 100; //  变量声明后,立即装入100。
        printf("%d\n", a); 
        return 0;
    }
    

      写法2:变量声明后,不初始化。后续使用赋值运算符赋值。

    #include <stdio.h>
    int main()
    {
        int a; //  变量声明后,为一个随机值
        a = 100; // 这里我们使用赋值运算符,将100给了a。
        printf("%d\n", a); 
        return 0;
    }
    

      另外,请注意:变量可以多次赋值,但是不能被多次初始化。多次初始化就相当于你重复定义了一个变量了。

    //  正确,将输出100,200。
    #include <stdio.h>
    int main()
    {
        int a; 
        a = 100; 
        printf("%d\n", a); 
        a = 200;
        printf("%d\n", a); 
        return 0;
    }
    
    //  错误,变量被声明过一次了。
    #include <stdio.h>
    int main()
    {
        int a; 
        a = 100; 
        printf("%d\n", a); 
        int a = 200; 
        printf("%d\n", a); 
        return 0;
    }
    

    5. 初始化和赋值的区别

      乍一看,初始化好像就是把变量声明和赋值写在一起了。对于整型和浮点变量确实如此。但是,对于后面将见到的其他类型,会略有不同。请区别对待初始化和赋值,这两个概念。

    6. 常量

      字面常量是程序中,一开始就被写死在代码中,且不能被改变的量。

    6.1 字面常量

      例如:100,200,1.3344,“HelloWorld”,被称之为字面常量。

    100 = 101;
    错误,常量不能被更改
    
    100 = a;
    错误,常量不能被更改
    

      字符串字面常量,被括号包裹的被称之为字符串常量。

    "HelloWorld"
    
    "HelloWorld" = "你好";
    错误,常量不能被更改
    

    6.2 符号常量

      假设我们有一个商品的价格price,目前为3元。现在我们要计算,10件这个商品的价格。

    #include <stdio.h>
    
    # define PRICE 3
    
    int main()
    {
    	int num = 10;
    	int total;
    	total = num * PRICE;
    	printf("total:%d", total);
    	return 0;
    }
    

      我们并没有直接写num * 3,而是定义了一个符号常量PRICE。这样做有什么好处呢?比如,我们这个程序很大,并且商品的价格被用在很多函数里面,不仅仅是main函数里。但是有一天,这个商品的价格变了。那么修改起来会很麻烦,这时呢。如果我们把商品的价格定义为符号常量,这样只要修改这个符号常量所代表的值即可了。

      定义符号常量的公式:

    #define 符号常量 值
    

    在这里插入图片描述

    展开全文
  • Python变量常量和值 在本教程中,您将学习Python变量常量、文字和它们的用例。 Python变量 变量是用于在内存中存储数据的命名位置。把变量看作是个容器是很有帮助的,它保存着可以在程序中稍后更改的数据。 ...

    Python变量,常量和值

    在本教程中,您将学习Python变量、常量、文字和它们的用例。

    Python变量

    变量是用于在内存中存储数据的命名位置。把变量看作是一个容器是很有帮助的,它保存着可以在程序中稍后更改的数据。

    例如:

    number = 10
    

    在这里,我们创建了一个名为number的变量。我们给这个变量赋了值10。

    你可以把变量想象成一个袋子,用来存放书,书可以在任何时候被替换。

    number = 10
    number = 1.1
    

    最初number的值是10。后来,它被更改为1.1。

    注意:在Python中,我们实际上并不给变量赋值。相反,Python将对象(值)的引用提供给变量。

    在Python中为变量赋值

    从上面的例子中可以看到,可以使用赋值操作符=给变量赋值。

    例1:为变量声明值并赋值

    website = "apple.com"
    print(website)
    

    在上面的程序中,我们给变量website赋值apple.com。然后,我们打印出分配给网站即apple.com的值。

    注意:Python是一种类型推断语言,所以您不必显式地定义变量类型。它自动知道apple.com是一个字符串,并将website变量声明为一个字符串。

    例2:更改变量的值

    website = "apple.com"
    print(website)
    
    # 给website一个新的值
    website = "programiz.com"
    
    print(website)
    

    在上面的程序中,我们最初将apple.com赋值给了website变量。然后,将该值更改为programiz.com。

    例3:给多个变量赋多个值

    a, b, c = 5, 3.2, "Hello"
    
    print (a)
    print (b)
    print (c)
    

    如果我们想一次给多个变量赋相同的值,可以这样做:

    x = y = z = "same"
    
    print (x)
    print (y)
    print (z)
    

    第二个程序将相同的字符串赋给所有三个变量x、y和z。

    Python常量

    常量是一种不能更改其值的变量类型。将常量看作容纳以后不能更改的信息的容器是很有帮助的。 你可以把常量想象成一个袋子,用来存放一些一旦放在袋子里就无法替换的书。

    在Python中给常量赋值

    在Python中,常量通常是在模块中声明和赋值的。在这里,模块是一个包含变量、函数等的新文件,它们被导入到主文件中。在模块内部,常量用大写字母书写,单词之间用下划线分隔。

    例:为常量声明值并赋值 创建一个constant.py:

    创建一个constant.py

    PI = 3.14
    GRAVITY = 9.8
    

    创建一个main.py

    import constant
    
    print(constant.PI)
    print(constant.GRAVITY)
    

    在上面的程序中,我们创建了一个constant.py模块文件。然后,我们将常量赋给PI和GRAVITY。之后,我们创建一个main.py文件并导入常量模块。最后,我们打印常量值。

    注意:实际上,我们在Python中不使用常量。用大写字母命名它们是将它们与变量分开的惯例,然而,这实际上并不能阻止重新赋值。

    变量和常量的规则和命名约定

    1. 常数和变量的名称应该由小写字母(a到z)或大写字母(a到z)或数字(0到9)或下划线(_)组成。
    2. 创建一个有意义的名字。例如,元音比v更有意义。
    3. 如果您想创建一个包含两个单词的变量名,请使用下划线将它们隔开。
    4. 使用可以声明常量的大写字母。
    5. 不要使用像!,@,#,$,%等特殊符号。
    6. 变量名不要以数字开头。

    变量、常量值

    值是在变量或常量中给出的原始数据。在Python中,有各种类型的字面量,它们如下:

    数字

    数字是不可变的。数值可以属于2种不同的数值类型:整数、浮点数。

    例:如何在Python中使用数字?

    a = 100
    float_1 = 10.5 
    float_2 = 1.5e2
    
    print(a)
    print(float_1, float_2)
    

    字符串

    字符串字面量是用引号括起来的字符序列。字符串可以使用单引号、双引号或三引号。

    而且,字符字面量是由单引号或双引号包围的单个字符。

    如何在Python中使用字符串?

    strings = "This is Python"
    char = "C"
    multiline_str = """This is a multiline string with more than one line code."""
    unicode = u"\u00dcnic\u00f6de"
    raw_str = r"raw \n string"
    
    print(strings)
    print(char)
    print(multiline_str)
    print(unicode)
    print(raw_str)
    

    在上面的程序中,Python是一个字符串字面值,而C是一个字符字面值。 赋给multiline_str的三重引号""“中的值是一个多行字符串字面值。 字符串u”\u00dcnic\u00f6de"是一个Unicode字面值,它支持英语以外的字符。在本例中,\u00dc表示Ü, \u00f6表示ö。 R "raw n string"是一个原始的字符串字面量。

    布尔类型

    一个布尔值可以有这两个值中的任意一个:True或False。

    如何在Python中使用布尔值?

    x = (1 == True)
    y = (1 == False)
    a = True + 4
    b = False + 10
    
    print("x is", x)
    print("y is", y)
    print("a:", a)
    print("b:", b)
    

    在上面的程序中,我们使用布尔值True和False。在Python中,True表示值为1,False表示值为0。x的值是True,因为1等于True。y的值是False,因为1不等于False。

    类似地,我们可以在数值表达式中使用True和False作为值。a的值是5,因为我们把值为1的True和4相加。类似地,b是10,因为我们将值为0的False与10相加。

    特殊字符

    Python包含一个特殊的字面量,即None。我们使用它来指定该字段尚未创建。

    如何在Python中使用特殊的文字?

    drink = "Available"
    food = None
    
    def menu(x):
        if x == drink:
            print(drink)
        else:
            print(food)
    
    menu(drink)
    menu(food)
    

    在上面的程序中,我们定义了一个菜单函数。在菜单中,当我们将参数设置为drink时,它显示为Available。当参数是food时,它显示None。

    集合

    有四种不同的字集合:列表、元组、Dict和Set。

    fruits = ["apple", "mango", "orange"] #list
    numbers = (1, 2, 3) #tuple
    alphabets = {'a':'apple', 'b':'ball', 'c':'cat'} #dictionary
    vowels = {'a', 'e', 'i' , 'o', 'u'} #set
    
    print(fruits)
    print(numbers)
    print(alphabets)
    print(vowels)
    

    在上面的程序中,我们创建了一个水果列表、一个数字元组、一个字典字典,字典的值与指定给每个值的键以及一组元音字母。

    展开全文
  • Rust:变量与常量

    千次阅读 2018-12-25 20:29:32
    在Rust中,每个值都属于某个数据类型,告知rust它被指定为何种数据以明确数据处理方式 文章目录1、标量整型浮点型布尔型字符类型2、复合类型元祖数组 rust有两种数据类型子集:标量和复合 1、标量 ...
  • Flutter(Dart)基础——变量常量

    万次阅读 2020-09-14 18:15:13
    Dart语法基础——变量常量 在 Dart 中,标识符以字母或下划线(_)开头,后跟任意字母和数字组合。 变量 使用 var 声明变量,可赋予不同类型的值。 未初始化时,默认值为 null。 变量的声明 变量用来存储对象的...
  • 全局变量是在所有函数体的外部定义的,程序的所有部分(其他文件的代码)都可以使用。全局变量不受作用域的影响。全局变量的生命周期一直到程序的结束,全局变量是静态存储方式。 例: #include &lt;stdio.h&...
  • C 语言编程 — 变量常量

    千次阅读 2020-04-02 20:15:59
    文章目录目录前文列表变量与常量变量变量的类型变量的声明变量的定义变量的初始化赋值常量整型常量浮点型常量字符型场景字符串常量常量的定义作用域 前文列表 《C 语言编程 — 数据类型》 变量与常量 C 中有两种...
  • 【C语言功法手册】第话 · 常量与变量的小课堂

    千次阅读 多人点赞 2022-05-05 12:19:09
    从今天开始,我将正式开启个新的打卡专题——《C语言百炼成神计划》,没错!百炼成神,目的是通过百天刷题计划,通过题目和知识点串联的方式,完成C语言的复习和巩固;后期还会配有专门的笔记总结和文档教程哦!想...
  • C和C++中全局变量,局部变量,静态变量常量

    万次阅读 多人点赞 2016-08-14 22:54:15
    C/C++中常量,静态变量,全局变量和局部变量的区别和作用。把局部变量改变为静态局部变量后是改变了它的存储方式即改变了它的生存期。把全局变量改变为静态全局变量是改变了它的作用域, 限制了它的使用范围。因此...
  • Java 中变量与常量的生命周期

    千次阅读 2017-12-28 14:23:00
    创建了一个内部内对象,并为其常量赋值,然后又一次常量进行了赋值,两次赋值都成功了。有同学提出疑惑,于是老师说到了栈内存以及内部变量常量的生命周期问题。 之前也提到过很多次关于这个“生命周期...
  • 在基本数据类型中,常量可分为整型常量、实型常量、符号常量和字符型常量(包括字符常量和字符串常量),现分别介绍如下:目录:常量二、C语言标识符三、变量四、变量命名规则附录:ASCII码表常量1.整型常量即...
  • C语言常量 变量与作用域

    千次阅读 2022-03-22 20:17:52
    变量与常量常量与符号常量constdefine二.变量变量定义命名规则1.变量定义语句2.变量赋初值typedef 常量与符号常量 整型常量 以下是合法的整型常量表示形式: 256,-75,0(十进制整型常量) 0237,045,...
  • Kotlin系列之变量常量

    千次阅读 2018-02-09 11:17:11
    变量 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 属性&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; varval区别 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp; 自定
  • 变量常量函数

    千次阅读 2014-06-23 17:11:39
    1、使用typedef来创建别名 eg:typedef unsigned short int ...3、将个字符(如字母a)赋给char变量时,该变量实际存储的是个0~255的ASCII码数值。 4、转义字符:\a响铃 \b退格 \f换页 \n换行 \r 回车 \t 制表 \
  • Golang极速入门课四,变量与常量

    千次阅读 2022-04-27 22:06:47
    Golang的变量相较于其他语言的 int a 改为了 var a int,且通过语言来警告未使用...通过简短形式,使用 := 赋值操作符,也简便工作中不断声明变量的繁琐工作,当个返回使用到多个变量时不必将这些变量单独进行声明。
  • 4.常量与引用 4.1 const的最初动机 4.2 const与指针 4.3 const与函数 4.4 const与类 4.5 引用(&amp;) 4.6 复制构造函数 3.函数重载 函数名可以看做是个操作的名字。通过这些名字,可以写出易于人们...
  • 静态变量与静态函数

    千次阅读 2018-08-16 10:42:50
    1、栈区(stack):有编译器自动分配释放,存放函数的参数值、局部变量的值等,操作凡是类似于数据结构中的栈; 2、堆区(heap):一般有程序员分配和释放(动态存储分配),分配方式类似于链表; 3、全局区...
  • keil for arm中: staticconstuint8_ts_acBmpLogo030[len]__attribute__((at(0X800F000)))={0x80,0xC0,0xC0,0xC0,0xC0,0x80,xxxxxxx} 案例演示 下面我们用个例子演示一下,...将个const常量放置到0x0000100...
  • 写比较复杂的c++代码时,我们往往会把代码分成几个片段放在几个不同的cpp文件中,这就引发了关于全局常量(如PI的共享)和全局变量的声明定义问题。 假设我们有头文件main.h和源文件a.pp,b.pp;其中a.pp和b.pp都...
  • 全局变量:在函数外声明的变量都成为全局变量,作用域是整个PHP文件,但在自定义的函数内部不能使用,想在用户自定义的函数内部使用全局变量,必须用global关键字声明变量,或者使用全局数组$globals进行访问 ...
  • ????笔者的前言 照理来说 在正常的大学里 都...注:由于笔者已经会Java了 C的一些概念和Java是相通的 因此部分变量函数之类的详细的基本概念就不在此阐述了 部分笔者已经会了的知识点和概念 或者部分C和Java重复的概念
  • 【Angular】变量常量声明解构

    千次阅读 热门讨论 2017-12-14 16:38:23
    常量 angular中 全局变量在类的外面,@Component()的上面声明 ... Angular中变量声明有两种方式,种是let,另种是var 作用域  let:只在块级作用域内有效  var:只在包含它的函数,模块中有效
  • 我们先来看看Java中的变量与...第一次赋值后,后面不可以再对其再次赋值。Java中的变量在程序运行中可以动态的改变其值,如int a = 1; int b = 2; a = a + b;Java类似的,Scala中对应有 val、var对应常量变量的定
  • 前言: 莫问良人长短,从此山水不相逢。 、概述   大家都知道 Kotlin 现在被 Gooogle 定为 Android 的官方开发语言。Kotlin 在项目中的使用将会越来越广泛,这也掀起了波学习 Kotlin 的浪潮,作为名 ...
  • T-SQL中的常量与变量

    千次阅读 2019-02-22 16:11:38
    1.常量:在程序运行中其值不能改变的量 (1)字符串常量:字符串常量定义在单引号内。字符串常量包含字母、数字字符(a~z、A~Z和0~9)及特殊字符(如数字号#、感叹号!、at符@) (2)二进制常量: 在Transact—SQL中...
  • 常量和静态的区别和详解

    千次阅读 2019-11-25 19:42:24
    常量函数: 你在 int f(int s) 后面加了个const(int f(int s) const),表示这函数是常函数(只能被常量对象或指针或引用调用)。 常量函数调用规则: 常量函数不能修改除了静态成员变量以外的变量 常量函数不能...
  • 上一节中,了解了变量是可以改变存储值的容器,与变量相对的概念则是常量,相对的含义是指可变不可变。 2.1 了解常量概念及使用方法 常量的定义指在程序运行过程中不可改变的量,可以使用const用以描述个存储...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 294,815
精华内容 117,926
热门标签
关键字:

一次函数变量与常量的概念