前言：

通常，数组变量的长度必须有常量表达式进行定义，但是在C99中，有时候也可以使用非常量表达式

1.代码演示：

#include<stdio.h>

int main(void){
	int i, n;
	
	printf("你想颠倒多少个数字？");
	scanf("%d",&n);
	
//	printf("n=%d\n",n);//调试 
	int a[n];//C99 only
	
	printf("请输入%d个整数：",n);
	for(i=0;i<n;i++){
		scanf("%d",&a[i]);//录入数字 
	}
	
//	printf("n=%d\n",n);//调试 
	printf("颠倒输出：");
	for(i=n-1;i>=0;i--){
		printf(" %d",a[i]);//空格分开数字 
	} 
	printf("\n");
	
	return 0;
} 

2.运行结果：

你想颠倒多少个数字？12
请输入12个整数：1 2 3 4 5 6 7 8 9 10 11 12
颠倒输出： 12 11 10 9 8 7 6 5 4 3 2 1

--------------------------------
Process exited after 13.18 seconds with return value 0
请按任意键继续. . .

3.原理解释：

• 上面程序的数组a[n]是一个变长数组（VLA），变长数组具有特征如下：
  1. 变长数组的长度是在程序执行时计算的，而非如常规那样在程序编译时计算
  2. 主要优点是不必在构造数组时随便给定一个长度，程序在执行过程中可以准确计算出所需元素个数，避免过长（浪费资源）或过短（溢出出错）。
  3. 变长数组的长度不一定要用变量来指定，任意表达式都可以
     int a[3*i+5];
     int b[j+k];
  4. 变长数组的主要限制是它们没有静态存储期限（下面详细讲）
  5. 变长数组没有初始化式（很自然，没有固定数量自然不能初始化）
  6. more……

4.静态存储期限

• 变量都是有存储期限的，也就是它们的生命周期，分为自动存储期限和静态存储期限
• 拥有自动存储期限的变量在所属块被执行时获得内存单元，并在块终止时释放内存单元。我们平时随手定义的变量都属于此范畴，生命周期在{块}中。
• 静态存储期限的变量则不需要考虑变量声明的位置，static变量只在程序执行时被初始化一次，然后全程都可以使用，存储位置一直没有改变，但是千万不要以为它和全局变量一样，局部静态存储期限的变量任然是块内可见，并且全局静态变量还限制了只有本源文件内可见，其他源文件不可见。总之，静态存储期限把变量的位置限制固定，但是并没有提升其可见区域。
• 如下是一个静态数组的妙用，仔细体会：

#include<stdio.h>
void fillArry();

int main(void){
	
	int i;
	
	for(i=0;i<12;i++)
	{
		fillArry(); //此处不需要填入任何传递值，也不需要任何返回值，降低了耦合性 
	} 
	return 0;
}

void fillArry(){
	static int j=0;//用于自增 
	static int a[12]={0};//用于记住上次调用的赋值
	a[j]=j;
	j++;//j=12时，数组已经赋值完毕 
	while(j==12){
		int i; 
		for(i=0;i<12;i++){
		printf("%d ",a[i]); //最后把静态数组输出，以验证每次调用都延续之前的结果	
		} 
		j++;
		 
	}	
} 

输出结果：

0 1 2 3 4 5 6 7 8 9 10 11
--------------------------------
Process exited after 0.03233 seconds with return value 0
请按任意键继续. . .

• 以上是静态存储期限的妙用，静态存储期限变量会固定存储位置，这也就意味着，其存储由栈转移到静态存储区，可变长数组的长度都不固定，肯定没法放在固定的位置，这也从一个角度理解了为什么可变长数组不可以由静态存储期限。

可变长数组

代码实现

package zgo_algorithm

import (
	"fmt"
	"sync"
)

// Array 可变长数组
type Array struct {
	array []int      // 固定大小的数组，用满容量和满大小的切片来代替
	len   int        // 真正长度
	cap   int        // 容量
	lock  sync.Mutex // 为了并发安全使用的锁
}

// MakeArray 新建一个可变长数组
// 时间复杂度为：O(1)，因为分配内存空间和设置几个值是常数时间。
func MakeArray(len, cap int) *Array {
	s := new(Array)
	if len > cap {
		panic("数组的长度不能大于容量")
	}

	// 把切片当数组用
	array := make([]int, cap, cap)

	// 元数据
	s.array = array
	s.cap = cap
	s.len = 0
	return s
}

// Append 增加一个元素
// 添加元素中，耗时主要在老数组中的数据移动到新数组，时间复杂度为：O(n)
func (a *Array) Append(element int) {
	// 并发锁
	a.lock.Lock()
	defer a.lock.Unlock()

	// 大小等于容量，表示没多余位置了
	if a.len == a.cap {
		// 没容量，数组要扩容，扩容到两倍
		newCap := 2 * a.len

		// 如果之前的容量为0，那么新容量为1
		if a.cap == 0 {
			newCap = 1
		}

		newArray := make([]int, newCap, newCap)

		// 把老数组的数据移动到新数组
		for k, v := range a.array {
			newArray[k] = v
		}

		// 替换数组
		a.array = newArray
		a.cap = newCap

	}

	// 把元素放在数组里
	a.array[a.len] = element
	// 真实长度+1
	a.len = a.len + 1

}

// AppendMany 增加多个元素
func (a *Array) AppendMany(element ...int) {
	for _, v := range element {
		a.Append(v)
	}
}

// Get 获取某个下标的元素
// 因为只获取下标的值，所以时间复杂度为 O(1)
func (a *Array) Get(index int) int {
	// 越界了
	if a.len == 0 || index >= a.len {
		panic("索引超过了长度")
	}
	return a.array[index]
}

// Len 返回真实长度
// 时间复杂度为 O(1)
func (a *Array) Len() int {
	return a.len
}

// Cap 返回容量
// 时间复杂度为 O(1)
func (a *Array) Cap() int {
	return a.cap
}

// 转换为字符串输出，主要用于打印
func (a *Array) ToString() (result string) {
	result = "["
	for i := 0; i < a.Len(); i++ {
		// 第一个元素
		if i == 0 {
			result = fmt.Sprintf("%s%d", result, a.Get(i))
			continue
		}

		result = fmt.Sprintf("%s %d", result, a.Get(i))
	}
	result = result + "]"
	return
}

测试

package zgo_algorithm

import (
	"fmt"
	"testing"
)

func TestArray(t *testing.T) {
	// 创建一个容量为3的动态数组
	a := MakeArray(0, 3)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", a.ToString())

	// 增加一个元素
	a.Append(10)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", a.ToString())

	// 增加一个元素
	a.Append(9)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:", a.ToString())

	// 增加多个元素
	a.AppendMany(8, 7)
	fmt.Println("cap", a.Cap(), "len", a.Len(), "array:",a.ToString())

}

输出结果

=== RUN   TestArray
cap 3 len 0 array: []
cap 3 len 1 array: [10]
cap 3 len 2 array: [10 9]
cap 6 len 4 array: [10 9 8 7]
--- PASS: TestArray (0.00s)
PASS

1，了解C89标准和C99中数组的区别

以下摘自C89标准和C99标准C11标准的区别

对数组的增强–可变长数组
　　C99中,程序员声明数组时,数组的维数可以由任一有效的整型表达式确定,包括只在运行时才能确定其值的表达式,这类数组就叫做可变长数组,但是只有局部数组才可以是变长的.可变长数组的维数在数组生存期内是不变的,也就是说,可变长数组不是动态的.可以变化的只是数组的大小.可以使用*来定义不确定长的可变长数组。

因此，windows上不支持以下程序(c98?)，但linux gcc就支持(c99)，仅仅是因为它们的编译器支持不同的标准，下面我们说那个标准不支持更准确:

int b;
int a[b];  # c98和c99都不支持这种
void test2(int n) {
	//scanf("%d", &n);
	int a[n];# c98不支持，c99支持，谭浩强说支持但实测的不支持，又是标准惹的祸吧
	a[0] = 1;
	printf("%d\n", a[0]);
}
int main() {
		int a = 43;
		test2(a);  # c98不支持，c99支持
		return 0;
	}

以下摘自C99可变长数组VLA详解

在程序设计过程中，我们常常遇到需要根据上下文环境来定义数组的情况，在运行期才能确知数组的长度。对于这种情况，C90及C++没有什么很好的办法去解决（STL的方法除外），只能在堆中创建一个内存映像与需求数组一样的替代品，这种替代品不具有数组类型，这是一个遗憾。C99的可变长数组为这个问题提供了一个部分解决方案。可变长数组（variable length array，简称VLA）中的可变长指的是编译期可变，数组定义时其长度可为整数类型的表达式，不再象C90/C++那样必须是整数常量表达式。

2，变长数组很方便，但为什么还是建议有限制地使用？

以下内容整理自C语言为什么不建议把变量作为数组长度
（1）支持VLA(变长数组)的编译器都大多数在栈上分配，但也有在堆上分配的，如armcc的VLA默认是直接使用系统的malloc,free来实现的，据说armcc的VLA用堆还是用栈是可以配置的，我没有深究，若你不确定你的编译器会以何种方式生成VLA代码的时候，不要假定它是基于栈实现的。这是一个比较容易出BUG的点。要避免这种BUG的方式其实也很简单，那就是避免使用VLA。即当要分配的空间长度上界比较小时，你可以使用固定数组大小的形式分配，浪费一点点不用也没关系；当你要分配空间的长度的上界比较大时，直接使用动态分配malloc等函数。

(2)因为这里面有太多的坑了，如果你不明白其中原理的话，那么你很容易掉坑里面。变长数组的实现是通过动态设置栈顶来实现的，也就是说这个东西还是在栈上而不是在堆里，这就带来了问题：第一，因为栈的大小是有限制的所以你的每次动态声明相当于调用了一次alloca，不知道这东西的可以自己去查下，其实他们的原理是一样的，通过设置栈顶在栈空间分配一块空间。所以动态数组不能太大。第二，这个东西因为实现在栈上面所以跟栈相关的操作都跟他互相有影响，比如上面提到的alloca，这个东西于动态数组的区别在于作用域，alloca在分配在函数内有效，但是动态数组在最内层括号内有效。但是（这里是重点），因为他们都在栈上面，所以一旦动态数组失效后，在其后分配的alloca也会被free，所以会产生很多不可预料的问题。比如这段代码:

int test()
{
    int a = 10;
    char *c;

    {
        char b[a];
        a = 8 * 1024;
        c = alloca(a);
    }

    char d[a];

    memset(c, 0, a);
    memset(d, 2, a);

    return c[0];
}

编译运行你会得到一个core dump
以下通过在堆上动态申请空间来替代VAL.
malloc(sizeof(Type) * number)…
calloc(sizeof(Type), number)
p = malloc (sizeof (*p) *number)