关于c语言auto变量和static变量区别

Posted 2023-04-13

请解释一下区别#include<studio.h>void AddOne()     auto int ia=1     ia=ia+1     printf("%d\n",ia);int main()     print("the first number is:")     AddOne();     print("the second number is:")     AddOne();     return 0;-----------------------------------------------------------#include<studio.h>void AddOne()     static int ia=1     ia=ia+1     printf("%d\n",ia);int main()     print("the first number is:")     AddOne();     print("the second number is:")     AddOne();     return 0;

自动变量(auto变量)和静态变量(static变量)主要有以下几点区别：

1、static变量存放在静态存储区，在程序整个运行期间都不释放；而auto变量存放在动态存储区，随着生命周期的结束而立即释放。

2、static变量只赋值一次，以后就不用赋值；而auto变量在函数每调用一次都要赋初值。

3、如果用户不对static变量赋初值，则默认为0或'\\0'；而auto变量为不确定值。

扩展资料：

auto变量

自动变量（Automatic Variable）指的是局部作用域变量，具体来说即是在控制流进入变量作用域时系统自动为其分配存储空间，并在离开作用域时释放空间的一类变量。

在许多程序语言中，自动变量与术语“局部变量”（Local Variable）所指的变量实际上是同一种变量，所以通常情况下“自动变量”与“局部变量”是同义的。

参考资料来源：百度百科-自动变量

参考技术A

一、主体不同

1、auto变量：是一个C/C++语言存储类型，仅在语句块内部使用。

2、static变量：在计算机编程领域指在程序执行前系统就为之静态分配存储空间的一类变量。

二、作用域范围不同

1、auto变量：初始化可为任何表达式，其特点是当执行流程进入该语句块的时候初始化可为任何表达式。

2、static变量：针对某一源文件的以static声明的文件级变量与函数的作用域只限于文件内（只在文件内可见），也即“内部连接”,因而可以用来限定变量的作用域。

三、特点不同

1、auto变量：具有自动存储期的变量在进入声明该变量的程序块时被建立，它在该程序块活动时存在，退出该程序块时撤销。

2、static变量：在函数内以static声明的变量虽然与自动局部变量的作用域相同，但存储空间是以静态分配而非默认的自动分配方式获取的，因而存储空间所在区域不同。

参考资料来源：百度百科-静态变量

参考资料来源：百度百科-auto

参考技术B

1、存储部位不同

auto变量会存储在堆栈里面，每次定义的时候会分配存储区，而在用完释放的时候会收回存储区。

static变量会被存储在静态存储区。

2、初始化不同

初始化的时候，如果不赋初值，auto变量是不确定的。C默认的就是auto类型。static变量声明的时候，如果不初始化，编译器会自动初始化。

3、保留的数据不同

static 变量，每次使用的时候会保留上一次的值，即使重新定义，也不会改变static 变量的值。而auto变量不会。

扩展资料

static变量用途

1、作常量使用

静态变量也可以用于存储常数。具体来说，静态变量（全局变量及汇编语言里定义的符号亦同）可用const，constant或final（根据语言决定）等关键字标识，这时其值就会在编译时设定，并且无法在运行时改变。

编译器通常将静态常量与文本一起置于目标文件的文本区域，而非常量初始化数据则置于数据区；而如若有需要，有些编译器还可选择为其开辟专用区；为防止常数变量被错误的指针写入覆盖，亦可在这块区域启用内存保护机制。

2、C族语言中的实现

在C语言及由其派生出的C++与Objective-C等程序语言中，“static”是用于控制变量的生命周期和连接方式（即其作用域，亦即可见性）的保留字。

确切来说，正如C族语言中的extern，auto与register这些保留字一样，static也是一种存储类（此处的“类”与面向对象语言的“类”的定义不同）标识。

每个变量与函数都有以上的一种存储类标识，如果在声明中没有明确标识其存储类，编译时就会根据上下文来选择其默认存储类，如在源文件里的所有文件级变量对应的默认存储类是extern，而在函数体内的变量对应的则是auto，各存储类的属性如下表所列。

参考资料来源：百度百科-静态变量

参考技术C 自动变量(auto变量)和静态变量(static变量)主要有以下几点区别：
1、static变量存放在静态存储区，在程序整个运行期间都不释放；而auto变量存放在动态存储区，随着生命周期的结束而立即释放。
2、static变量只赋值一次，以后就不用赋值；而auto变量在函数每调用一次都要赋初值。
3、如果用户不对static变量赋初值，则默认为0或'\0'；而auto变量为不确定值。 参考技术D auto变量存储在动态存储区，static变量存储在静态存储区，主要区别是：在多次使用被调函数中，每执行一次，auto的值都保留原始值（与你的程序执行没关系），但是static却和调用函数的具体过程有关，即保留上次的值，两者在主函数中的功能是一样的。

黑马程序员C语言基础（第七天）内存管理

黑马程序员C语言基础（第七天）内存管理

文章目录

• 内存管理
• • 作用域
  • • 8.1.1 局部变量（auto自动变量）
    • 8.1.2 静态(static)局部变量
    • • 普通局部变量和静态（static）局部变量的区别
    • 8.1.3 全局变量
    • • 跨文件使用全局变量示例（没用头文件）
      • 跨文件使用全局变量示例（用头文件）
    • 8.1.4 静态(static)全局变量
    • 8.1.5 extern全局变量声明
    • 8.1.6 全局函数（普通函数）和静态函数（static函数）
    • 8.1.7 总结
  • 8.2 内存布局
  • • 8.2.1 内存分区（text代码区、data区、bss区、栈区、堆区）
    • 8.2.2 存储类型总结（有用！）
    • • 栈越界：指分配的内存空间超出了栈的范围（ulimit -a）
    • 8.2.3 存储类型总结内存操作函数
    • • 1) memset()（将s的内存区域的前n个字节以字符c填入）（注意是以字节为单位填入，一个字节填入一个字符的ascii码）
      • 2) memcpy()（拷贝src所指的内存内容的前n个字节到dest所值的内存地址上）（即使遇到 \\0 也能拷贝）
      • 3) memmove()（内存重叠时代替memcpy()使用）（内存重叠：使用memcpy拷贝的过程中原数组值发生变化，使得结果不正确）（踩内存）
      • 4) memcmp()（主要用来比较两个地址前n个字节是否相等）
    • 8.2.4 堆区内存分配和释放
    • • 1)malloc()
      • 2)free()
  • 8.3 内存分区代码分析(在Linux下测试)
  • • 1) 返回栈区地址
    • 2) 返回data区地址
    • 3) 值传递1
    • 4) 值传递2
    • 5) 返回堆区地址（较上面两种完美）

内存管理

作用域

C语言变量的作用域分为：

• 代码块作用域(代码块是{}之间的一段代码)
• 函数作用域
• 文件作用域

8.1.1 局部变量（auto自动变量）

局部变量也叫auto自动变量(auto可写可不写)，一般情况下代码块{}内部定义的变量都是自动变量，它有如下特点：

• 在一个函数内定义，只在函数范围内有效
• 在复合语句中定义，只在复合语句中有效
• 随着函数调用的结束或复合语句的结束局部变量的声明声明周期也结束
• 如果没有赋初值，内容为随机

注意：auto关键字在c++ .cpp文件下不能识别

#include <stdio.h>

void test()
{
	//auto写不写是一样的
	//auto只能出现在{}内部
	auto int b = 10; 
}

int main(void)
{
	//b = 100; //err， 在main作用域中没有b

	if (1)
	{
		//在复合语句中定义，只在复合语句中有效
		int a = 10;
		printf("a = %d\\n", a);
	}

	//a = 10; //err离开if()的复合语句，a已经不存在
	
	return 0;
}

8.1.2 静态(static)局部变量

• static局部变量的作用域也是在定义的函数内有效
• static局部变量的生命周期和程序运行周期一样，同时staitc局部变量的值只初始化一次（如：static int i =10;只能运行一次），但可以赋值多次
• static局部变量若未赋以初值，则由系统自动赋值：数值型变量自动赋初值0，字符型变量赋空字符

#include <stdio.h>

void fun1()
{
	int i = 0;
	i++;
	printf("i = %d\\n", i);
}

void fun2()
{
	//静态局部变量，没有赋值，系统赋值为0，而且只会初始化一次
	static int a;
	a++;
	printf("a = %d\\n", a);
}

int main(void)
{
	fun1();
	fun1();
	fun2();
	fun2();
	
	return 0;
}

结果：

i = 1
i = 1
a = 1
a = 2

普通局部变量和静态（static）局部变量的区别

8.1.3 全局变量

声明用extern关键字声明

跨文件使用全局变量也同样要先声明

• 在函数外定义，可被本文件及其它文件中的函数所共用，若其它文件中的函数调用此变量,须用extern声明
• 全局变量的生命周期和程序运行周期一样
• 不同文件的全局变量不可重名

跨文件使用全局变量示例（没用头文件）

main.cpp

#include <stdio.h>


int main(void)
{
	extern void test();
	test();

	extern int a;
	extern int b;
	a = 111;
	b = 222;
	printf("a = %d, b= %d\\n", a, b);

	return 0;
}

fun.cpp

#include <stdio.h>
#include <stdlib.h>
#include <String.h>

int a = 10;
int b = 5;
void test() {
	a = 1;
	b = 1;
}

运行结果：

a = 111, b= 222

跨文件使用全局变量示例（用头文件）

main.cpp

#include <stdio.h>
#include "test.h"

int main(void)
{
	test();
	a = 111;
	b = 222;
	printf("a = %d, b= %d\\n", a, b);

	return 0;
}

fun.cpp

#include <stdio.h>
#include <stdlib.h>
#include <String.h>

int a = 10;
int b = 5;
void test() {
	a = 1;
	b = 1;
}

test.h

#pragma once
extern void test();
extern int a;
extern int b;

运行结果：

a = 111, b= 222

8.1.4 静态(static)全局变量

• 在函数外定义,作用范围被限制在所定义的文件中
• 不同文件静态全局变量可以重名,但作用域不冲突
• static全局变量的生命周期和程序运行周期一样，同时staitc全局变量的值只初始化一次

8.1.5 extern全局变量声明

extern int a;声明一个变量，这个变量在别的文件中已经定义了，这里只是声明，而不是定义。

8.1.6 全局函数（普通函数）和静态函数（static函数）

在C语言中函数默认都是全局的，使用关键字static可以将函数声明为静态，函数定义为static就意味着这个函数只能在定义这个函数的文件中使用，在其他文件中不能调用，即使在其他文件中声明这个函数都没用。

对于不同文件中的staitc函数名字可以相同。

注意：

• 允许在不同的函数中使用相同的变量名，它们代表不同的对象，分配不同的单元，互不干扰。
• 同一源文件中,允许全局变量和局部变量同名，在局部变量的作用域内，全局变量不起作用。
• 所有的函数默认都是全局的，意味着所有的函数都不能重名，但如果是staitc函数，那么作用域是文件级的，所以不同的文件static函数名是可以相同的。

8.1.7 总结

auto变量就是局部变量（普通变量），extern变量就是全局变量，extern函数就是普通函数

8.2 内存布局

size ./out
可以看区？

还真可以！

dontla@dontla-virtual-machine:~/桌面/test$ size test
   text	   data	    bss	    dec	    hex	filename
   1820	    608	      8	   2436	    984	test

8.2.1 内存分区（text代码区、data区、bss区、栈区、堆区）

C代码经过预处理、编译、汇编、链接4步后生成一个可执行程序。
在 Linux 下，程序是一个普通的可执行文件，以下列出一个二进制可执行文件的基本情况：

通过上图可以得知，在没有运行程序前，也就是说程序没有加载到内存前，可执行程序内部已经分好3段信息，分别为代码区（text）、数据区（data）和未初始化数据区（bss）3 个部分（有些人直接把data和bss合起来叫做静态区或全局区）。

• 代码区
  存放 CPU 执行的机器指令。通常代码区是可共享的（即另外的执行程序可以调用它），使其可共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可。代码区通常是只读的，使其只读的原因是防止程序意外地修改了它的指令。另外，代码区还规划了局部变量的相关信息。

• 全局初始化数据区/静态数据区（data段）
  该区包含了在程序中明确被初始化的全局变量、已经初始化的静态变量（包括全局静态变量和局部静态变量）和常量数据（如字符串常量）。

• 未初始化数据区（又叫 bss 区）
  存入的是全局未初始化变量和未初始化静态变量。未初始化数据区的数据在程序开始执行之前被内核初始化为 0 或者空（NULL）。

程序在加载到内存前，代码区和全局区(data和bss)的大小就是固定的，程序运行期间不能改变。然后，运行可执行程序，系统把程序加载到内存，除了根据可执行程序的信息分出代码区（text）、数据区（data）和未初始化数据区（bss）之外，还额外增加了栈区、堆区。

• 代码区（text segment）
  加载的是可执行文件代码段，所有的可执行代码都加载到代码区，这块内存是不可以在运行期间修改的。

• 未初始化数据区（BSS）（Block Started by Symbol）
  加载的是可执行文件BSS段，位置可以分开亦可以紧靠数据段，存储于数据段的数据（全局未初始化，静态未初始化数据）的生存周期为整个程序运行过程。

• 全局初始化数据区/静态数据区（data segment）
  加载的是可执行文件数据段，存储于数据段（全局初始化，静态初始化数据，文字常量(只读)）的数据的生存周期为整个程序运行过程。

• 栈区（stack）
  栈是一种先进后出的内存结构，由编译器自动分配释放，存放函数的参数值、返回值、局部变量等。在程序运行过程中实时加载和释放，因此，局部变量的生存周期为申请到释放该段栈空间。

• 堆区（heap）
  堆是一个大容器，它的容量要远远大于栈，但没有栈那样先进后出的顺序。用于动态内存分配。堆在内存中位于BSS区和栈区之间。一般由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收。

8.2.2 存储类型总结（有用！）

#include <stdio.h>
#include <stdlib.h>

int e;
static int f;
int g = 10;
static int h = 10;
int main()
{
	int a;
	int b = 10;
	static int c;
	static int d = 10;
	char *i = "test";
	char *k = NULL;

	printf("&a\\t %p\\t //局部未初始化变量\\n", &a);
	printf("&b\\t %p\\t //局部初始化变量\\n", &b);

	printf("&c\\t %p\\t //静态局部未初始化变量\\n", &c);
	printf("&d\\t %p\\t //静态局部初始化变量\\n", &d);

	printf("&e\\t %p\\t //全局未初始化变量\\n", &e);
	printf("&f\\t %p\\t //全局静态未初始化变量\\n", &f);

	printf("&g\\t %p\\t //全局初始化变量\\n", &g);
	printf("&h\\t %p\\t //全局静态初始化变量\\n", &h);

	printf("i\\t %p\\t //只读数据(文字常量区)\\n", i);

	k = (char *)malloc(10);
	printf("k\\t %p\\t //动态分配的内存\\n", k);

	return 0;
}

&a       00D3FA00        //局部未初始化变量
&b       00D3F9F4        //局部初始化变量
&c       0118A18C        //静态局部未初始化变量
&d       0118A048        //静态局部初始化变量
&e       0118A184        //全局未初始化变量
&f       0118A188        //全局静态未初始化变量
&g       0118A040        //全局初始化变量
&h       0118A044        //全局静态初始化变量
i        01187B30        //只读数据(文字常量区)
k        00FF04D0        //动态分配的内存

栈越界：指分配的内存空间超出了栈的范围（ulimit -a）

在linux下用ulimit -a指令查看各个空间大小：

可以看到栈的空间为8192kbytes，也就是8Mb

dontla@dontla-virtual-machine:~/桌面/test$ ulimit -a
core file size          (blocks, -c) 0
data seg size           (kbytes, -d) unlimited
scheduling priority             (-e) 0
file size               (blocks, -f) unlimited
pending signals                 (-i) 111644
max locked memory       (kbytes, -l) 65536
max memory size         (kbytes, -m) unlimited
open files                      (-n) 1024
pipe size            (512 bytes, -p) 8
POSIX message queues     (bytes, -q) 819200
real-time priority              (-r) 0
stack size              (kbytes, -s) 8192
cpu time               (seconds, -t) unlimited
max user processes              (-u) 111644
virtual memory          (kbytes, -v) unlimited
file locks                      (-x) unlimited

放visual studio上也会报错：（但大小好像不太一样？）

8.2.3 存储类型总结内存操作函数

1) memset()（将s的内存区域的前n个字节以字符c填入）（注意是以字节为单位填入，一个字节填入一个字符的ascii码）

#include <string.h>
void *memset(void *s, int c, size_t n);
功能：将s的内存区域的前n个字节以参数c填入
参数：
	s：需要操作内存s的首地址
	c：填充的字符，c虽然参数为int，但必须是unsigned char , 范围为0~255
	n：指定需要设置的大小
返回值：s的首地址

#include <stdio.h>
#include <String.h>

int main()
{
	int a[10];

	memset(a, 0, sizeof(a));
	memset(a, 97, sizeof(a));
	//memset(a, 'a', sizeof(a));//都可以
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		printf("%c\\n", a[i]);
	}

	return 0;
}

结果：

a
a
a
a
a
a
a
a
a
a

示例：以字节为单位初始化

2) memcpy()（拷贝src所指的内存内容的前n个字节到dest所值的内存地址上）（即使遇到 \\0 也能拷贝）

#include <string.h>
void *memcpy(void *dest, const void *src, size_t n);
功能：拷贝src所指的内存内容的前n个字节到dest所值的内存地址上。
参数：
	dest：目的内存首地址
	src：源内存首地址，注意：dest和src所指的内存空间不可重叠
	n：需要拷贝的字节数
返回值：dest的首地址

示例1：

#include "cal.h"
#include<stdio.h>
int main() { 
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int b[10] = {0};

	memcpy(b, a, sizeof(a));

	for (int i = 0; i < 10; i++)
	{
		printf("%d, ",*(b+i));
	}
	printf("\\n");

	//memcpy(&a[3], a, 5 * sizeof(int)); //err, 内存重叠
}

结果：

1, 2, 3, 4, 5, 6, 7, 8, 9, 10,

示例2：

#include <stdio.h>
#include <String.h>

int main()
{
	char p[] = "adfsfdsf\\0assfs";
	//printf("%s\\n", p);//adfsfdsf
	//printf("%d\\n",sizeof(p));//15
	char buf[100];

	strncpy_s(buf, p, sizeof(p));
	printf("%s\\n", buf);//adfsfdsf
	printf("%s\\n", buf + strlen("adfsfdsf") + 1);//无（说明strncpy没法将\\0后面的字符拷贝过去）
	
	memset(buf, 0, sizeof(buf));
	memcpy(buf, p, sizeof(p));
	printf("%s\\n", buf);//adfsfdsf
	printf("%s\\n", buf + strlen("adfsfdsf") + 1);//assfs
	return 0;
}

3) memmove()（内存重叠时代替memcpy()使用）（内存重叠：使用memcpy拷贝的过程中原数组值发生变化，使得结果不正确）（踩内存）

memmove()功能用法和memcpy()一样，区别在于：dest和src所指的内存空间重叠时，memmove()仍然能处理，不过执行效率比memcpy()低些。

4) memcmp()（主要用来比较两个地址前n个字节是否相等）

#include <string.h>
int memcmp(const void *s1, const void *s2, size_t n);
功能：比较s1和s2所指向内存区域的前n个字节
参数：
	s1：内存首地址1
	s2：内存首地址2
	n：需比较的前n个字节
返回值：
	相等：=0
	大于：>0
	小于：<0

#include <stdio.h>
#include <String.h>

int main()
{
	int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	int b[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

	int flag = memcmp(a, b, sizeof(a));
	printf("flag = %d\\n", flag);//flag = 0
}

8.2.4 堆区内存分配和释放

1)malloc()

#include <stdlib.h>
void *malloc(size_t size);
功能：在内存的动态存储区(堆区)中分配一块长度为size字节的连续区域，用来存放类型说明符指定的类型。分配的内存空间内容不确定，一般使用memset初始化。
参数：
	size：需要分配内存大小(单位：字节)
返回值：
成功：分配空间的起始地址
失败：NULL

#include <stdlib.h> 
#include <stdio.h>
#include <string.h>

int main()
{
	int count, * array, n;
	printf("请输入要申请数组的个数:\\n");
	scanf_s("%d", &n);

	array = (int*)malloc(n * sizeof(int));
	if (array == NULL)
	{
		printf("申请空间失败!\\n");
		return -1;
	}
	//将申请到空间清0
	memset(array, 0, sizeof(int) * n);

	for (count = 0; count < n; count++) /*给数组赋值*/<
以上是关于关于c语言auto变量和static变量区别的主要内容，如果未能解决你的问题，请参考以下文章
 
 c语言的auto和static类型变量
 C语言中auto，register，static，const，volatile的区别
 请问在C语言中,auto和static分别代表啥意思,有啥作用,谢谢
 c语言—变量
 c语言static在java语言区别
 C语言的关键字