黑马程序员_第四天视频学习 数组 字符串 指针

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

一、 数组：

       1、概念

含义：用来存储一组数据的；

              构造类型：有无数个基本数据类型组成的类型；

              特点：(1)、只能存放一种类型的数据；(2)、里面存放的数据称为“元素”；

       2、数组的定义

              定义格式：数据类型数组名[元素个数]；

              简单使用：

a、  简单的初始化；int age[3] ={23,53,3};

b、 元素有顺序之分，每个元素都有一个唯一的下标（索引），从0开始

c、  数组元素的访问：a[i]

遍历：按顺序查看数组的每个元素

#include <stdio.h>

int main()

{

int age[3] = {23,53,3};

for(int i = 0; i <5;i++)

{

              printf(“age[%d]= %d\n”,I,age[i]);

}

return 0;

}

初始化写法：

       只能在定义数组的同时进行初始化，定义初始化时数组元素个数只能是常量。

int a[3]={1,2,3};

int a[3]={1};

int a[3]={ [2]=1,[0]= 2};

int a[]={1,2,3};

int a[‘A’]={1,2,3};

              错误写法:

                     int a[];  int[] a; a={1,2,3};  a[3]={1,2,3};；

int count=3;

int a[count]={1,2,3};//这是错误的

                     int a[count];          //这是可以的，但未定义的数组元素的值是不确定的

                     a[0]=1;

                     如果想在定义数组的同时进行初始化，数组元素个数必须是常量，或不写；定义数组过程中并没有进行初始化，数组元素个数可以是变量。

       3、计算数组的长度(计算数组元素的个数)

int a[]={1,2,3};

              int count =sizeof(a)/sizeof(a[0]);

       4、数组的内存存储细节

              a、存储空间的划分：内存的分配是从高地址到低地址进行的，但一个数组内部元素又是从低到高进行的；

              b、数组名就代表数组的地址；

                     每个元素的地址

       #include<stdio.h>

int main()

{

int a[3] = {23,53,3};

                            for(int i=0;i<3;i++)

{

              printf(“a[%d]的地址是：%p\n”,i,&a[i]);

}

return 0;

                     }

       4、数组和函数

              数组作为函数的参数，可以省略元素个数

              void change(int arr[])

{

                     int a = sizeof(arr);              //这个计算的不是数组的字符长度，而是地址类型的长度

                     printf(“传递参数后的长度:%d”,a);

}

int main()

{

              Int a[]={1,2,3,4,5,6};

              Change(a);

return 0;

}

              数组作为函数参数，是进行地址传递，传递的是整个数组的地址，修改函数形参数组元素的值，会影响到外面的实参数组。

              //设计一个函数：将一维整型数组中的元素逆序存放。比如本来是1,3,4,2，逆序存放就变成了：2，4，3，1

              #include<stdio.h>

int main()

{

                    int a[]={4,6,2,23,42,4,53};

      intlength = sizeof(a)/sizeof(a[0]);

      voidarrayChange(int arr[], int length);

      arrayChange(a,length);

     printf("一维整型数组中的元素逆序存放的结果是\n");

     for(int i=0; i<length; i++) {

       printf("%d\n",a);

     }

     return0;

}

void arrayChange(int arr[],int length)

{

   int chan;

   for(int i=0; i<length/2; i++)

    {

       chan=arr[ i ];

       arr[ i ]=arr[length-1-i];

       arr[length-1-i]=chan;

    }

}

5、二维数组：是一个特殊的一维数组，他的数组元素是一维数组

二、字符串

1、概念

含义：是很多字符组合在一起形成的字符串    “news”

              初始化：

                     char name[8]=”news”;

                     char name1[8]={‘n’,’e’,’w’,’s’,’\0’};

                     char name2[8]={‘n’,’e’,’w’,’s’,0 };

                     char name3[8]={‘n’,’e’,’w’,’s’};//可以看作是隐藏了’\0’;

                     char name4[]={‘n’,’e’,’w’,’s’};//这个不算是一个字符串，只能说是一个字符数组

              输出： %s

                     printf(“字符串输出：%s”,name);

2、’\0’的作用：字符串结束的标志

              %s是从输出的变量的地址开始一个一个的输出字符，直到遇到’\0’为止；

                     #include<stdio.h>

int main()

{

                            char user[]=”hello”;

                          charname[]={‘o’,’k’};

     printf("%s\n",name);//从name地址开始输出，结果是okhello;

         return0;

}

3、常用字符串处理函数

              strlen();//计算字符串长度。

              #include<stdio.h>

#include <string.h>

int main()

{

                     char user[]=”hello你好”;

                     int length =strlen(user);

            printf("%d\n", length);//结果是11

         return0;

}

a、  计算的是字符数，不是字数；

b、 计算的字符不包括’\0’;

c、  从某个地址开始数字符的个数，直到遇到’\0’为止

4、字符串数组

              char name[2][15]={“news”,”hello”};

 

三、指针

       1、指针变量的定义

              格式：变量类型 *变量名； int *p;

              指针变量的作用：只能存储地址；

              指针变量占据8个字节；

              int a =10;

              int *p = &a;//定义一个指针变量p，指针变量p指向了变量a

              *p访问指针变量p所指向的存储空间。

              *p = 10; 相当于 a = 10;

              指针的作用：能够根据一个地址值，访问对应的存储空间；

              指针变量p前面的int代表指针变量p只能指向int类型的数据；

       2、指针的使用注意

              a、指针变量只能指向同类型的数据，不能乱用类型；

                     如，int p; doubled=10.0;p=&d;这样*p意味着从地址开始找4个字节的空间，而d拥有8个字节的空间。

              b、指针变量只能存储地址；int *p =200;这是不合理的，地址都是很大的数

              c、指针变量未经过初始化，不要拿来间接访问其他存储空间

              d、定义变量时的*仅仅是一个象征，没有其他特殊含义；*p =20，这个时候的*的作用是：访问指针变量p指向的存储空间。

              int *p = &a;//这个是定义变量

              *p=&a;//这个是将&a这个地址存入了*p所指向的存储空间，也就是自己存自己地址。

       3、 指向指针的指针

              #include<stdio.h>

int main()

{

                     int a =10;

                     int *p = &a;

                     int **pp = &p;//指向p的指针

                     int ***ppp = &pp;//指向pp的指针

                     a=20;*p=20;*(*pp)=20;***ppp=20;这四个是一样的

                     return 0;

}

       指针可以做到，一个函数可以有无限个返回值。

       4、指针的一些疑问

              任何指针都占用8个字节的存储空间。

              为什么指针要分类型：int在赋值和取值的时候，根据地址来赋值和获取它及以后的4个字符的值，返回。

       5、指针与数组

              #include<stdio.h>

int main()

{

                     int a[] ={1,2,3,4};

       //指针变量p指向了数组的首元素

                     int *p = a;//int *p = &a[0]//这两个是相同的

       *p== &a[0];

       *(p+1)== &a[1];//p+1是意味着指针的地址值+类型所占字节数

       *(p+2)== &a[2];

       return0;

}

              数组元素的访问方式

a、  数组名[下标]；

b、 指针变量名[下标]

c、  *(指针变量名+下标)

#include <stdio.h>

void change( int *arr) //获取的是数组的首元素

{

       printf(“%d\n”,arr[2]);

       printf(“%d\n”,*(arr+2));

}

int main()

{

       inta[] ={1,2,3,4};

       change(a);

       return0;

}

              利用指针来接收一个数组，指针变量arr指向了数组的首元素。

       6、指针与字符串

              定义字符串的2种方式：

a、  利用数组 char name[]=”abcd”;

特点：字符串里面的字符是可以修改的；

使用场合：字符串的内容需要经常修改；

b、 利用指针 char *name=”abcd”;\

特点：字符串其实是一个常量字符串，里面的字符是不能修改的；

使用场合：字符串的内容不需要修改，而且这个字符串经常使用；

7、指针数组(字符串数组)：char *name[4]={“abc”,”hello”,”hi”,”ok”};

       二维字符数组(字符串数组)：char name[4][8]={“abc”,”hello”,”hi”,”ok”};

8、返回指针的函数

       #include<stdio.h>

char *test()

{

              return "hello";

}

int main()

{

              char *name = test();

              return 0;

}

       9、指向函数的指针

              void (*p)();//定义指向函数的指针

              (*p)是固定写法，代表指针变量p将来肯定是指向函数；

              左边的void：指针变量p指向的函数没有返回值

              右边的()：指针变量p指向的函数有没有形参

              函数名代表函数地址

              #include<stdio.h>

char test()

{

       printf("调用了test函数\n");

}

int main()

{

       void(*p)();

       p= test;//指针变量p指向了test函数

       //调用函数三种方式

       (*p)();//利用指针变量间接调用函数

       p();//因为p = test

       test();//直接调用函数

       return0;

}

#include <stdio.h>

char sum( int a, int b)

{

       returna+b;

}

int main()

{

       int(*p)(int, int);

       p= sum

       intsum = p(10,15);

       intsum1 = (*p)(10,15);

       intsum2 = sum(10,15);

       printf("sum=%d\nsum1=%d\nsum2=%d\n",sum,sum1,sum2);

       return0;

}

 

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------