数组和指针

数组-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. 数组类型

1. c语言中存在数组类型，例：int array[5]的类型为int[5]
2. 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';`去修改字符串中的元素，会发生段错误，程序去写了只读区