数组和指针

数组-20151215
数组的初始化

数组名的含义

指针和数组
柔性数组

指针和数组的区别定义为指针声明为数组

比较数组拷贝和指针拷贝效率谁高-用指针和数组分别拷贝一万个数据

指针数组和数组指针
- 数组指针
数组类型

定义数组指针

应用数组指针

- 指针数组

字符串
字符串储存空间

数组-2015/12/15

1.数组的初始化

int a[5];//这种初始化数组里面的元素是随机值。
int a[5]={0};//这种初始化编译器会默认所有元素初始化为0
//用meset函数把数组元素置0，效率低于初始化

2.数组名的含义

￥数组名代表数组首元素的起始地址。

￥数组的地址要用&才能得到。

￥数组名可以看作常量指针不能直接作为左值

char a[5]={0};
printf("0X%d--0X%d",a,&a);
printf("0X%d--0X%d",a+1,&a+1);
//输出
//：0X163681--0X163681
//：0X163681--0X163681

a+1是加了一个char，而&a+1是加了整个数组即5个char

所以a和&a的地址虽然相同，但含义不同

指针和数组

柔性数组

1.指针和数组的区别—–定义为指针声明为数组

//anther.c
char p="hello world"//p为指针

//main.c
#include <stdio.h>
extern char p[];//声明为数组
int main(void)
{
printf("%s",p);
}

//打印出的值为乱码

因为声明为数组后，使用printf就是默认p是数组的首地址，而实际上p为一个指针，p中储存的是一个4byte地址，printf就直接把这个地址当做字符串打印出来了，所以乱码。

若声明为指针默认会对p中的指针进行一次寻址

如果将错就错的声明为数组，改如何打印出正确的结果呢？

p本身是一个4byte的字符型指针，所以可以还原回去

1.(unsigned int*)p 强制转化还原为地址指针（32位）

2.* ((unsigned int*)p) 去寻址这个地址

3.

printf("%s\n",(char* )(*((unsigned int*)p));

作为字符指针打印出来

2.比较数组拷贝和指针拷贝效率谁高-用指针和数组分别拷贝一万个数据

#include <stdio.h>
#include <time.h>
#include <stdlib.h>
//把一万个数据拷贝到另外的一个地址
int main()
{
clock_t start;//开始时间
clock_t end;//结束时间
int a[10000];
int b[10000];
int* pEnd = &a[10000];
int* pa = NULL;
int* pb = NULL;
int i = 0;
int k = 0;

start = clock();//获取开始时间
//拷贝运算
for (k = 0; k<10000; k++)
{
for (i = 0; i<10000; i++)
{
b[i] = a[i];
}
}
end = clock();//获取结束时间
printf("Index Timing: %d\n", end - start);//打印出数组拷贝用的时间

start = clock();
for (k = 0; k<10000; k++)//实现指针拷贝
{
for (pa = a, pb = b; pa<pEnd;)
{
*pb++ = *pa++;
}
}
end = clock();
printf("Pointer Timing: %d\n", end - start);//打印出指针拷贝时间

system("PAUSE");
return 0;
}

指针数组和数组指针

- 数组指针

1. 数组类型

c语言中存在数组类型，例：int array[5]的类型为int[5]

c语言通过typedef为数组重命名：typedef type(name)[size]

typedef int(AINT5)[5];//定义AINT5数组类型
typedef float(Afloat10)[10];

AINT5 iArray;//即为int iArray[5];
Afloat fArray//即为float fArray[10];

2. 定义数组指针

int a[5];
int *p1 = a;//定义一个指针指向a[0];
typedef int(AINT5)[5];//定义一个int[5]类型的数组
AINT *p2 = &a;//定义一个数组指针指向数组a的起始地址
//上面两句也可以等价于
int(*p2)[5] = &a;

3. 应用数组指针

1. 关于array+1和&array+1的另一种解释

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
char array[5];
char *p1 = array;      //p1指向array的第一个元素
char *p2 = &array;//警告>char *与char (*)[10]存在隐式转换
char (*p3)[5] = &array;//定义一个类型为char[5]的数组指针
printf("0X%X\n", p1);      //==>0X18F93C
printf("0X%X\n", p2+1);    //==>0X18F93C+1
printf("0X%X\n", array);   //==>0X18F93C+1
printf("0X%X\n", &array+1);//==>0X18F93C+5
printf("0X%X\n", p3+1);    //==>0X18F93C+5
system("PAUSE");
return 0;
}

- 指针数组

1. 寻找指针数组中指定的关键字字符串

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define DIM(A) sizeof(A)/sizeof(*A)
//只能求数组的长度，不能求指针指向的数组的长度
int find_key(const char* s, const char* table[], unsigned int size)
{
unsigned int i = 0;
int ret = -1;
for (i = 0; i < size; i++)
{
if(strcmp(s, table[i])==0)ret = i;
}
return ret;
}
int main()
{
char i;
char* a[10] = { "return",
"void",
"static",
"sizeof",
"typedef",
"struct",
"enum",
"switch",
"case",
"const"
};
i = find_key("case", a, DIM(a));
i>=0 ? printf("%s\n",a[i]) : printf("该关键字不存在\n");;
system("PAUSE");
return 0;
}

2. 获得字符串中的单词，并对该单词进行存储，以形成字符串数组

字符串

字符串储存空间

c语言中没有字符串类型，所以用以’\n’结尾的字符数组来模拟

c语言中的字符串可以储存在栈区、堆区、静态存储区(只读存储区)(区别)

变量储存在哪里

#include<stdio.h>
#include<stdlib.h>
void main(void)
{
char a0[] = {'H','e','l','l','o'};//存在栈空间
char a1[] = {'H','e','l','l','o','\n'};//存在栈空间
char *p1 = "hello";//存在静态存储区中的只读常量区域
char *p2 = "hello";//编译器会优化让p1和p2指向同一个地址，即只读常量在程序中只有一份备份
char p3 = malloc(6 * sizeof(char));//存在堆空间
printf("%d\n%d",p1,p2);
}
//如果用`p3[2] = 'l';`去修改字符串中的元素，会发生段错误，程序去写了只读区