精华内容
下载资源
问答
  • 如果指针p,a都是在main函数中定义的,在test函数中不能直接调用,main也是个函数只不过是第一个执行的函数,mian里面定义的变量也是局部变量 有选择的情况下不用全局变量,全局指针,特别是在一个大型的程序里...

    全局变量、本地变量、静态本地变量

    • 全局变量的初始化发生在main函数之前,没有初始化的全局变量会得到0值,指针会得到NULL。

    • 局部变量没有初始化,会出现一个乱七八糟的值。内存中有什么就得到了什么结果。全局变量初始化时只能被赋值为一个编译器已知的值,一般是一个常数

    • 如果指针p,和a都是在main函数中定义的,在test函数中不能直接调用,main也是个函数只不过是第一个执行的函数,mian里面定义的变量也是局部变量

    • 有选择的情况下不用全局变量,全局指针,特别是在一个大型的程序里,因为全局的东西大家都可以修改他,你不知道哪个函数就给他调用了修改了,就会导致程序出错,指针还有可能在别的地方将内存释放掉。

    • 如果有与局部变量的名字一样的话,全部变量会被隐藏而不是被覆盖

    //
    int quanju = 12;
    int quanju2 = quanju1;   //报错
    
    //
    int quanju=12;
    void main(){
        f();    //这里局部变量覆盖全局,输出1
        printf("%d",quanju);    //这里全局回来了,输出12
    }
    void f (void ){
        int quanju = 1;
        printf("%d",quanju);
    }
    
    • 静态本地变量

    在本地变量前加入 static 修饰,当函数离开时,他会继续存在并保存其值。静态本地变量的初始化只会在第一次进入函数的时候做,以后进入函数保持上次离开的值。

    静态本地变量实际上是全局变量,他的生存期是全局,内存空间是全局,作用域只在函数内部。

    int quanju=1;
    int main()
    {
        f();
        return 0;
    }
    
    int f(void )
    {
        int k=0;
        static int a=1;
        printf("&quanju=%p\n",&quanju);
        printf("&a=%p\n",&a);
        printf("&k=%p\n",&k);
             
    }
    
    //从这个和实验可以看出静态本地变量和全局变量存放在相邻的内存空间中
    

    一个返回本地变量地址的指针是危险的。因为本地变量的内存出了函数以后就被释放掉了,这个内存就会被别的变量使用。

    返回全局变量或者是静态本地变量是安全的,?但是使用这两个的函数是线程不安全的

    展开全文
  • C语言中的变量分为全局变量和局部变量,全局变量的作用域是整个函数,声明周期与整个程序的声明周期一样。局部变量只能在该函数内部访问和使用,但是如果把一个局部变量定义成是静态的,那就是一个定义在函数内部的...

    C语言中的静态本地变量

    C语言中的变量分为全局变量和局部变量,全局变量的作用域是整个函数,声明周期与整个程序的声明周期一样。局部变量只能在该函数内部访问和使用,但是如果把一个局部变量定义成是静态的,那就是一个定义在函数内部的全局变量了。
    一个局部静态变量会在程序运行到整个函数的时候才会被创建,然后会一直持续到这个程序结束才被释放,程序离开该函数的时候这个局部变量的值会等于离开之前的值

    #include<stdio.h>
    
    int Jubu();
    
    int main()
    {
    	Jubu();
    	Jubu();
    	Jubu();
    	return 0;
    }
    int Jubu()
    {
    	static int val=1;
    	printf("val=%d\n",val);
    	val++;
    }
    
    展开全文
  • 局部变量2. 全局变量3. 全局静态变量4. 本地静态变量5. 变量类型总结内存1.内存四区2. 堆栈的区别3. 显示目标文件分区大小 变量的作用域与生存期 变量的隐形性质 变量的作用域与生存期相当于“攻击范围”“生命...

    变量的作用域与生存期

    变量的隐形性质
    变量的作用域生存期相当于“攻击范围”和“生命力”

    1. 作用域

    编译时可能出现这样的问题

    #include <stdio.h>
    
    int main(){
        int n =0;
        for(int i=0;i<10;++i){
           n += i;
        }
        printf("%d %d\n",i,n);
    }
    

    编译失败:
    在这里插入图片描述

    输出时找不到 i 的定义
    大括弧相当于加了一层作用域

    局部变量作用域是在变量定义的大括号以内

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

    能编译成功

    作用域如果出问题,编译器会给报错

    2. 生存期

    程序中的变量超出生存期,编译器可能不报错

    错误:函数中返回局部变量的指针,结果出错

    #include <stdio.h>
    int* func(){
        int n=10;
        int* p = &n;
        return p;
    }
    
    int main() {
        int* p = func();
        printf("打印这部分没意义\n");
        printf("*p = %d\n",*p);
        return 0;
    }
    

    结果为:

    打印这部分没意义
    *p = 32766
    

    不要把局部变量的地址传了出去
    不要返回函数内定义的指针

    错误:函数中返回局部变量的数组地址,吐核

    #include <stdio.h>
    void print_array(int arr[],int n){
        for(int i=0;i<n;++i){
            printf("%d ",arr[i]);
        }
        printf("\n");
    }
    int* scanf_array(int* n){
        scanf("%d",n);
        int arr[*n];    // 在函数内定义,是局部变量
        for(int i=0;i<*n;++i){
            scanf("%d",&arr[i]);
        }
        return arr;     // 不能返回局部变量地址
    }
    int main(){
        int n;
        int *arr = scanf_array(&n);
        print_array(arr,n);
    }
    

    函数 scanf_array 中定义了 arr,但返回 arr 的地址,执行时就会吐核
    可以返回地址,但不要返回局部变量的地址

    3. 同名隐藏

    在同一作用域下,两个变量不能重名
    在不同的作用域下,内部变量会隐藏外部变量

    同名隐藏会出现这样的问题

    #include <stdio.h>
    
    int main(){
            int n = 10;
            printf("%p %d\n",&n,n);
            {
                    printf("%p %d\n",&n,n);
                    int n=100;
                    printf("%p %d\n",&n,n);
                    n=1000;
            }
            printf("%p %d\n",&n,n);
    }
    

    结果为:

    0x7fff1251147c 10
    0x7fff1251147c 10
    0x7fff12511478 100
    0x7fff1251147c 10
    

    其中 n=1000; 改的是 n=100; 的值
    外 n 的作用域要扣除内 n 的作用域
    内 n 的作用域只负责从定义内 n 开始,到 } 结束


    变量的分类

    1. 局部变量

    此前定义的变量都是局部变量

    局部变量的特点

    1. 本地变量可以定义在代码块内
      可以定义在函数的块内
      可以定义在语句的块内
      可以定义在一个随意的大括弧里面
    2. 程序进入块前,内部变量不存在,离开时失效
    3. 块外定义的变量,块内仍然有效
    4. 不会默认初始化,必须我们给他初始化

    2. 全局变量

    全局变量的特点

    1. 全局变量整个程序都能看到
    2. 有全局的生命周期和作用域,生命周期是整个程序运行时间,所有函数都能使用
    3. 全局变量的定义要在使用处之前,和函数一样,当然也可以用 extern 提前声明
    4. 没有初始化的全局变量会默认初始化为 0

    全局变量的用法

    #include <stdio.h>
    
    extern int n;   //提前声明全局变量
    
    void PrintN(){
            printf("%p\n",&n);
            printf("n=%d\n",n);
    }
    
    int n;
    // int m=n;  这样是不允许的
    
    int main(){
            printf("%p\n",&n);
            scanf("%d",&n);
            PrintN();
    }
    

    结果为:

    0x601030
    15
    0x601030
    n=15
    

    使用全局变量的优点: 函数可以不用传参
    使用全局变量的缺点: 函数中若改了某个全局变量的值不易找到是哪个函数更改的

    错误:用编译时未知的值初始化全局变量,报错

    int n = 2;
    int m = n;
    double  s = sqrt(n); 
    int main(){
    		printf("n = %d,m = %d,s = %f",n,m,s);
    }
    

    第二行和第三行错误
    只能用编译时已知的值初始化全局变量

    全局变量在文件拆分中的应用:打印给定数组,并排序
    arr.c 文件内容

    int arr[] = {1,2,3,4,5,6};
    int n = 6;
    

    arr.h 文件内容

    #pragma once
    
    extern int arr[6];
    extern int n;
    

    printarr.c 文件内容

    #include <stdio.h>
    #include "printarr.h"
    #include "arr.h"
    
    void PrintArr(){
            for(int i=0;i<n;++i){
                    printf("%d ",arr[i]);
            }
            printf("\n");
    }
    

    printarr.h 文件内容

    #pragma once
    void PrintArr();
    

    dessort.c 文件内容

    #include <stdio.h>
    #include <stdlib.h>
    #include "printarr.h"
    #include "dessort.h"
    #include "arr.h"
    
    int cmp(const void* a,const void* b){
            return *(int*)b - *(int*)a;
    }
    void DesSort(){
            qsort(arr,n,sizeof(int),cmp);
            PrintArr(arr,n);
    }
    

    dessort.h 文件内容

    #ifndef _DESSORT_H
    #define _DESSORT_H
    void DesSort();
    #endif  // _DESSORT_H
    

    test.c 文件内容

    #include "printarr.h"
    #include "dessort.h"
    #include "arr.c"
    
    int main(){
            PrintArr();
            DesSort();
    }
    

    3. 全局静态变量

    在全局变量前加上关键字 static
    定义静态全局变量使得该变量只能用于本文件中
    具有外部链接的静态,可以在所有源文件里调用,除了本文件,其他文件可以通过 extern 的方式引用

    在上例中,在 arr.c 中做实验

    int arr[] = {1,2,3,4,5,6};
    int n = 6;
    
    int abc;   // 为了做实验随便定义的
    

    可以查看到 abc 默认也是全局变量

    [admin@localhost C14]$ gcc -c arr.c
    [admin@localhost C14]$ readelf -s arr.o
    
    Symbol table '.symtab' contains 10 entries:
       Num:    Value          Size Type    Bind   Vis      Ndx Name
         0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
         1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS arr.c
         2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 
         3: 0000000000000000     0 SECTION LOCAL  DEFAULT    2 
         4: 0000000000000000     0 SECTION LOCAL  DEFAULT    3 
         5: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 
         6: 0000000000000000     0 SECTION LOCAL  DEFAULT    4 
         7: 0000000000000000    24 OBJECT  GLOBAL DEFAULT    2 arr
         8: 0000000000000018     4 OBJECT  GLOBAL DEFAULT    2 n
         9: 0000000000000004     4 OBJECT  GLOBAL DEFAULT  COM abc
    

    如果变成全局静态变量

    int arr[] = {1,2,3,4,5,6};
    int n = 6;
    
    static int abc;   // 为了做实验随便定义的
    

    可以查看到 abc 是只能本文件可用

    [admin@localhost C14]$ gcc -c arr.c
    [admin@localhost C14]$ readelf -s arr.o
    
    Symbol table '.symtab' contains 10 entries:
       Num:    Value          Size Type    Bind   Vis      Ndx Name
         0: 0000000000000000     0 NOTYPE  LOCAL  DEFAULT  UND 
         1: 0000000000000000     0 FILE    LOCAL  DEFAULT  ABS arr.c
         2: 0000000000000000     0 SECTION LOCAL  DEFAULT    1 
         3: 0000000000000000     0 SECTION LOCAL  DEFAULT    2 
         4: 0000000000000000     0 SECTION LOCAL  DEFAULT    3 
         5: 0000000000000000     4 OBJECT  LOCAL  DEFAULT    3 abc
         6: 0000000000000000     0 SECTION LOCAL  DEFAULT    5 
         7: 0000000000000000     0 SECTION LOCAL  DEFAULT    4 
         8: 0000000000000000    24 OBJECT  GLOBAL DEFAULT    2 arr
         9: 0000000000000018     4 OBJECT  GLOBAL DEFAULT    2 n
    

    4. 本地静态变量

    在局部变量前加上关键字 static,这是一个特殊的全局变量
    作用域是局部的,但生存期贯穿整个程序运行期间
    初始化只初始化一次

    #include <stdio.h>
    
    int inc(){
            static int n = 0;   // 定义静态局部变量,函数第二次必经过此地
            n = n+1;
            return n;
    }
    
    int main(){
            printf("%d\n",inc());
            printf("%d\n",inc());
            printf("%d\n",inc());
            printf("%d\n",inc());
    }
    

    结果为:

    1
    2
    3
    4
    

    局部静态变量不能用变量做变量初始化,这和全局变量一样

    5. 变量类型总结

    变量类型 定义位置 作用域 生存期
    局部变量 定义在函数内 代码块,从变量定义开始到 } 结束 与作用域一致
    全局变量 定义在函数外 整个程序运行过程 整个程序运行过程
    静态全局变量 定义在函数外,static 修饰 当前文件 整个程序运行过程
    静态局部变量 定义在函数内,static 修饰 代码块,从变量定义开始到 } 结束 整个程序运行过程
    动态内存 任意位置 从 malloc 开始,到 free 结束 从 malloc 开始,到 free 结束

    通过程序体会动态内存的作用域和生存期

    #include <stdio.h>
    #include <stdlib.h>
    
    void print_arr(int arr[],int n){
            for(int i=0;i<n;++i){
                    printf("%d ",arr[i]);
            }
            printf("\n");
    }
    
    int* scan_arr(int* m){
            int n;
            scanf("%d",&n);
            // int arr[n];
            int* arr = malloc(n*sizeof(int));   // 定义动态内存
            for(int i=0;i<n;++i){
                    scanf("%d",arr+i);
            }
            *m = n;
            return arr;
    }
    
    int main(){
            int n;
            int* arr = scan_arr(&n);
            print_arr(arr,n);
            free(arr);
            arr = NULL;
    }
    

    但通常较为常用的程序

    #include <stdio.h>
    
    void print_arr(int arr[],int n){
            for(int i=0;i<n;++i){
                    printf("%d ",arr[i]);
            }
            printf("\n");
    }
    
    void scan_arr(int arr[],int n){
            for(int i=0;i<n;++i){
                    scanf("%d",arr+i);
            }
    }
    
    int main(){
            int n;
            scanf("%d",&n);
            int arr[n];
            scan_arr(arr,n);
            print_arr(arr,n);
    }
    

    结果为:

    5
    1 2 3 4 5
    1 2 3 4 5 
    

    内存

    1.内存四区

    在这里插入图片描述

    栈区stack: 函数参数、所有局部变量
    程序运行过程中变化的,地址向小的申请
    不初始化里面的值是随机的

    堆区heap: 动态申请内存
    程序运行过程中变化的,地址向大的申请

    数据区data: 全局变量、静态变量
    BSS里放的是没有初始化的变量,占用四个字节但不一定连续
    不初始化默认为0

    代码区text: 编写的代码,字符串指针常量
    此区域不能修改,所以之前说字符串指针常量不能修改

    查看内存分布程序:

    #include <stdio.h>
    #include <stdlib.h>
    
    int ga = 0;
    int gb = 0;
    int gc = 0;
    
    void Func1(){}
    void Func2(){}
    void Func3(){}
    
    int main(){
            //查看局部变量地址,在栈中
            int a;
            int b;
            int c;
            printf("&a = %p\n",&a);
            printf("&b = %p\n",&b);
            printf("&c = %p\n",&c);
            //查看动态内存地址,在堆中
            int* p1 = malloc(sizeof(int));
            int* p2 = malloc(sizeof(int));
            int* p3 = malloc(sizeof(int));
            printf("p1 = %p\n",p1);
            printf("p2 = %p\n",p2);
            printf("p3 = %p\n",p3);
            //查看初始化了的全局变量地址,在数据区中
            printf("&ga = %p\n",&ga);
            printf("&gb = %p\n",&gb);
            printf("&gc = %p\n",&gc);
            //查看静态局部变量地址,在数据区
            static int sa = 0;
            static int sb = 0;
            static int sc = 0;
            printf("&sa = %p\n",&sa);
            printf("&sb = %p\n",&sb);
            printf("&sc = %p\n",&sc);
            //查看函数地址,在代码区
            printf("Func1 = %p\n",&Func1);
            printf("Func2 = %p\n",&Func2);
            printf("Func3 = %p\n",&Func3);
            //查看字符串常量指针地址,在代码区
            char* s1 = "abcd";
            char* s2 = "1234";
            char* s3 = "!@#$";
            printf("s1 = %p\n",s1);
            printf("s2 = %p\n",s2);
            printf("s3 = %p\n",s3);
    }
    

    运行结果分析:

    &a = 0x7fff2ebddbcc
    &b = 0x7fff2ebddbc8
    &c = 0x7fff2ebddbc4        // 栈区,地址越来越小
    p1 = 0x1dfc6b0
    p2 = 0x1dfc6d0
    p3 = 0x1dfc6f0         // 堆区,地址越来越大
    &ga = 0x601030
    &gb = 0x601034
    &gc = 0x601038        // 数据区,初始化过的全局变量地址连续
    &sa = 0x60103c
    &sb = 0x601040
    &sc = 0x601044         // 数据区,静态局部变量地址连续
    Func1 = 0x4005d6
    Func2 = 0x4005dd
    Func3 = 0x4005e4      // 代码区,函数
    s1 = 0x4008ee
    s2 = 0x4008f3
    s3 = 0x4008f8        // 代码区,包括/0有五个字节
    

    2. 堆和栈的区别

    比较方面
    管理方式 由系统自动管理,以执行函数为单位 由程序员手动控制
    空间大小 编译时确定(参数+局部变量) 具有全局性,总体无大小限制
    分配方式 函数执行,系统自动分配;函数结束,系统立即自动收回 使用 malloc() 手动分配;使用 free() 手动释放
    优点 使用方便,不用关心内存申请释放 可以跨函数使用
    缺点 只能在函数内部使用 容易造成内存泄漏

    3. 显示目标文件分区大小

    对上述内存分配程序使用 size 命令
    只显示程序运行前固定的部分:代码段 text 、数据段 data 、BSS段 bss
    不显示运行后才生效的部分:栈 stack 、堆 heap

    [admin@localhost C13]$ size a.out
       text	   data	    bss	    dec	    hex	filename
       2151	    556	     28	   2735	    aaf	duizhan
    

    dec 和 hex 是前三个区域的和,dec 是十进制,hex 是十六进制

    展开全文
  • 任何编程中的范围都是程序的一个区域,其中定义的变量可以存在,并且超出该范围,无法访问它。有三个地方可以用C编程语言声明变量 l 在函数或块内部,称为局部变量。...本地变量不为其自身以外的函...

    任何编程中的范围都是程序的一个区域,其中定义的变量可以存在,并且超出该范围,无法访问它。有三个地方可以用C编程语言声明变量

    l 在函数或块内部,称为局部变量。

    l 在所有函数之外,称为全局变量。

    l 在函数参数的定义中称为形式参数。

    让我们了解什么是局部全局变量,以及形式参数。

    在函数或块内声明的变量称为局部变量。它们只能由该函数或代码块中的语句使用。本地变量不为其自身以外的函数所知。以下示例显示了如何使用局部变量。这里所有变量a,b和c都是main函数的局部变量。关于怎么快速学C/C++,可以加下小编的C/C++学习群:627+012+464,不管你是小白还是大牛,小编我都欢迎,不定期分享干货,欢迎初学和进阶中的小伙伴。每天晚上20:00都会开直播给大家分享C/C++游戏编程学习知识和路线方法,群里会不定期更新最新的教程

    更多C/C++学习资料,请私信我“代码”,即可获取

    全局变量在函数外部定义,通常在程序之上。全局变量在程序的整个生命周期中保持其值,并且可以在为程序定义的任何函数内访问它们。

    任何函数都可以访问全局变量。也就是说,全局变量在声明后可用于整个程序。以下程序显示了如何在程序中使用全局变量。

    程序对于局部变量和全局变量可以具有相同的名称,但函数内的局部变量的值将优先考虑。这是一个例子:

    编译并执行上述代码时,会产生以下结果:

    value of a in main = 10

    value of a in sum = 10

    value of b in sum = 20

    value of c in main = 30

    定义局部变量时,系统不会初始化它,您必须自己初始化它。当您按如下方式定义全局变量时,系统会自动初始化全局变量

    正确初始化变量是一个很好的编程习惯,否则你的程序可能会产生意想不到的结果,因为未初始化的变量将在其内存位置获取一些已经可用的垃圾值。

    我有一个微信公众号,经常会分享一些C语言/C++技术相关的干货;如果你喜欢我的分享,可以用微信搜索“C语言学习部落”关注

    欢迎大家加入千人交流答疑裙:627+012+464

    展开全文
  • C语言】数组函数

    2020-11-26 17:29:09
    2.3.3本地变量/局部变量/自动变量(作用域声明周期) 2.4 其他细节 这个课程内容的安排真的是很有条理,由易到难,由浅入深。比如讲解函数和数组之前,先通过例子说明为什么要引入它们,是为了方便解决某些问题...
  • 7.C语言调用帧结构

    万次阅读 2016-10-22 22:55:08
    一般地,机器只提供转移控制到过程从过程中转移出控制的简单指令,数据传递、局部变量的分配释放必然通过程序栈实现 机器用栈来传递过程参数、存储返回信息、保存寄存器用于以后恢复和本地存储。我们称为单个...
  • C语言函数调用栈

    2020-06-02 11:34:12
    编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。 不同处理器编译器的堆栈布局、函数调用方法都可能不同,但堆栈的基本概念是一样的。 ...
  • (3)本地符号:静态变量(包括全局和局部),静态函数 对于静态局部变量,编译器会为其生成唯一的名字。如x.fun1,x.fun2。本地符号对链接器来说是不可见的。 2. 符号决议 当编译器遇到一个不是本模块定义的符号时,...
  • C语言函数调用栈(一)

    万次阅读 多人点赞 2018-07-19 22:16:25
    编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。 不同处理器编译器的堆栈布局、函数调用方法都可能不同,但堆栈的基本概念是一...
  • Java语言与C语言的区别

    千次阅读 2018-12-05 19:57:23
    分别为栈区(存储的是局部变量,使用完毕,立即回收),堆区(存储的是new出来的东西,实体,对象,每一个对象都有地址值,每个对象的数据都有默认值,使用完毕后,会在垃圾回收器空闲的时候回收),方法区,本地...
  • C语言函数调用栈一

    2015-08-04 14:46:01
    编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。 不同处理器编译器的堆栈布局、函数调用方法都可能不同,但堆栈的基本概念
  • 程序的执行流程,实际是连续的函数调用...编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。 1 寄存器 寄存器用于存放程序执行中用到的数据指令
  • 关于C语言中的static

    2008-11-20 09:33:00
    每个可重定位目标模块m都有一个符号表(.symtab),它包含m所定义和引用的符号的信息,不包含局部变量的信息。链接器的上下文(context)中有三种不同的符号(变量和函数): 1、由m定义并能被其他模块引用的全局...
  •  局部变量一般使用较短的变量名,外部变量使用较长的名字。C语言提供一下几种基本数据类型。 char 字符型,占用一个字节,可以存放本地字符集中的一个字符。 int 整型, 通常反映了所用及机器中整数的最自然长度...
  • C语言标准库--官网

    千次阅读 2013-08-07 14:41:19
    本文包括大部分C标准库函数,但没有列出一些用途有限的函数以及某些可以简单的从其他函数合成的函数,也没有包含多字节和本地化函数。 标准库中的各个函数、类型以及宏分别在以下标准头文件中说明: ...
  • C语言函数调用栈(1)

    2018-06-27 23:51:44
    程序的执行过程可看作...编译器使用堆栈传递函数参数、保存返回地址、临时保存寄存器原有值(即函数调用的上下文)以备恢复以及存储本地局部变量。 不同处理器编译器的堆栈布局、函数调用方法都可能不同,但堆栈的...
  • 由于嵌套函数定义无法访问周围块的局部变量,因此它们只能访问包含模块的全局变量。这样做是为了不必在目录中查找全局变量。与C中一样,有两个嵌套作用域:本地和全局(除此之外,内置函数)。因此,嵌套函数只有...
  • C语言大全第4版(高清PDF中文版)

    热门讨论 2011-06-07 09:23:56
    2.4.2 局部变量 2.4.3 形式参数 2.4.4 全局变量 2.4.5 C语言的四个域 2.5 类型修饰符 2.5.1 const 2.5.2 volatile 2.6 存储类型说明符 2.6.1 extern 2.6.2 static变量 2.6.3 register...
  • 目录一、测试相关二、C语言、数据结构和算法三、...全局变量和局部变量的区别?当两者名字一样时调用时是优先局部变量还是全局变量? 堆栈、队列的区别? 怎样由两个堆栈组成一个队列? 快排的时间、空间复杂度? 在
  • 函数

    2017-04-20 22:26:00
    本地变量局部变量、自动变量指的都是一种东西。 本地变量的生存期、作用域都是以大括号为准的,都是定义在块内的,进入这个块之前,变量不存在,离开这个块之后,变量就消失了。 块外面定义的变量在块内仍然有效...
  • Static内联函数

    千次阅读 2016-12-28 17:27:47
    定义为static的局部变量存储在全局区(静态区),而一般的局部变量存储在栈中。 --- 在模块内(但在函数体外),一个被声明为静态的变量可以被模块内所有函数访问,但不能被模块外其他函数访问。它是一个本地的全局...
  • Block小结

    2019-09-23 23:34:15
    用一句话来表示Blocks的扩充功能:带有自动变量(局部变量)的匿名函数。  block其实是一个代码块,但是它的神奇之处在于在内联(inline)执行的时候(这C++很像)还可以传递参数。同时block本身也可以被作为参数在方法...
  • 全局变量和局部变量5.临时确保局部变量使用的内存空间6.循环控制语句的处理7.条件分支的处理方法8.了解程序运行逻辑的必要性 一、汇编语言和本地代码 计算机CPU只能运行本地代码(机器语言) 程序, 用C语言等高级...
  • static的作用

    2017-10-29 22:30:08
    c语言中,其有三个作用,(1)存储区域属于静态存储区 ,改变变量的生存周期,如局部变量变成静态局部变量。(2)初始化默认为0,例如给一个数组或者字符数组初始化0时,省去工作,这功能得益于其存储变变量的静态...
  • 40.用某种语言编写的程序就称为...42.栈,是用于存储函数内部临时使用的变量(局部变量),以及函数调用时所使用的的参数的内存区域。 堆,是用于存储程序运行过程时的任意对象及数据的内存区域。 栈空间由编译器管理

空空如也

空空如也

1 2 3
收藏数 58
精华内容 23
关键字:

c语言本地变量和局部变量

c语言 订阅