黑马程序员--C语言——数组



------ Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

数组的基本概念

数组是构造类型。

数组就是用来存储一组数据的

数组的特点

只能存放一种类型的数据，比如int类型的数组、float类型的数组，里面存放的数据称为“元素”

数组的定义

元素类型 数组名[元素个数];

比如：int ages[3];

简单使用

简单初始化：int ages[5] = {19, 19, 20, 21, 25};

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

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

数组初始化

初始化方式

int a[3] = {10, 9, 6};

int a[3] = {10,9};

int a[] = {11, 7, 6};

int a[4] = {[1]=11,[0] = 7};

常见错误

int a[];

int[4] a;

a = {10, 11};

a[4] = {10,9,8,5};

int b=5;int a[b]={1,2,3}这样是不对的。如果在定义数组的同时进行初始化，数组个数必须是常量或者不写。如果想这么写有下面的方法。不同时进行初始化。

int b=5;int a[b];a[0]=1;a[1]=2;a[2]=3;这种写法是正确的。但是a[]与a[b]两种写法的区别是前者的a[3],a[4]是0，后者是不确定的数。

内存分析

数组存储空间的大小

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

数组名的作用，查看元素地址

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

数组作为函数参数（sizeof计算数组长度sizeof(ages)/sizeof(int)）

两种方式遍历（while循环和for循环）一般为for

遍历元素值和元素地址

字符数组的使用

/*

设计一个函数，找出整型数组元素的最大值

*/

#include <stdio.h>

int maxOfArray(int array[], int length)

    // 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节

    //int size = sizeof(array);

    //printf("array=%d\n", size);

    //sizeof(array);

    // 1.定义一个变量存储最大值(默认就是首元素)

    int max = array[0];

    // 2.遍历所有元素，找出最大值

    for (int i = 1; i<length; i++)

    {

        // 如果当前元素大于max，就用当前元素覆盖max

        if (array[i] > max)

        {

            max = array[i];

        }

    }

    return max;

}

int main()

{

    int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};

    int max = maxOfArray(ages, sizeof(ages)/sizeof(int));

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

    return 0;

}

二维数组

二维数组是一个特殊的一维数组：它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素

初始化

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

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

数组元素简单访问

int a[][5] = {3,21,31,2,32,1};

注意错误：

int a[3][4];

a[3] = {};

 

遍历

遍历所有的元素，遍历地址

使用场合：五子棋、俄罗斯方块.二维数组讲解视频

字符串

简单的字符串”itcast”

一个’i’是一个字符

很多个字符组合在一起就是字符串了

字符串的初始化

char a[] = “123”; 字符串。Printf(a)把数组传入仅仅是个警告。

 和 char a [] = {‘1’,’2’,’3’};字符数组

 “123”其实是由’1’、’2’、’3’、’\0’组成

字符串的输出”%s”，’\0’是不会输出的

\0的作用

输出

char a1[]=”itc\0a”

char a2[] = {‘o’,’k’};

printf(“%s\n”,a2);

输出okitc.

1	a2	o
2		k
3	a1	i
4		t
5		c
6		\0
7		a
8		\0

 

常用字符串处理函数

Strlen：计算字符串长度

1   计算的是字符数并不是字数。

2  计算字符数不包括\0

Sizeof和strlen的区别

比如一个数组，int a[10]="abcd",strlen(a)=4计算的是字符串长度,sizeof(a)=10计算的是开辟的内存空间，
比如一个指针，int *p="abcd".strlen(p)=4计算的是字符串长度.sizeof(a)=4,计算的是指针p占据的内存空间。

习题

编写一个函数char_contains(char str[],char c)，如果字符串str中包含字符c则返回数值1，否则返回数值0

 

/*

编写一个函数char_contains(char str[],char c)，

 如果字符串str中包含字符c则返回数值1，否则返回数值0

*/

#include <string.h>

#include <stdio.h>

// 可读性 -> 性能 -> 精简（重构）

int char_contains(char str[], char c);

int main()

{

    //int result = char_contains("itc8ast", '8');

    char name[] = "itcast";

    int result = char_contains(name, 'o');

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

    return 0;

}

// "itc"  '7'

int char_contains(char str[], char c)

{

    int i = -1；

    // 1.遍历整个字符串

    while ( str[++i] != c && str[i] != '\0' ) ;

    //return str[i] == '\0' ? 0 : 1;

    return str[i] != '\0';

}

/*

int char_contains(char str[], char c)

{

    int i = -1;

    // 1.遍历整个字符串

    while ( str[++i] )

    {

        // 如果发现某个字符等于参数c，直接返回1，退出函数

        if (str[i] == c)

        {

            return 1;

        }

    }

    // 2.说明str里面不包含字符c

    return 0;

}*

/*

int char_contains(char str[], char c)

{

    int i = 0;

    // 1.遍历整个字符串

    while ( str[i] != '\0' )

    {

        // 如果发现某个字符等于参数c，直接返回1，退出函数

        if (str[i] == c)

        {

            return 1;

        }

        i++;

    }

    // 2.说明str里面不包含字符c

    return 0;

}*/

/*

int char_contains(char str[], char c)

{

    // 1.遍历整个字符串

    for (int i = 0; i<strlen(str); i++)

    {

        // 如果发现某个字符等于参数c，直接返回1，退出函数

        if ( str[i] == c )

        {

            return 1;

        }

    }

    // 2.说明str里面不包含字符c

    return 0;

}*/

 

字符串数组

1.使用场合

* 一维字符数组中存放一个字符串，比如一个名字char name[20] = "mj"

* 如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)

* 如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20]

2.初始化

char names[2][10] = { {'J','a','y','\0'}, {'J','i','m','\0'} }; 

char names2[2][10] = { {"Jay"}, {"Jim"} }; 

char names3[2][10] = { "Jay", "Jim" };

 

指针前奏

指针的重要性

指针是C语言中非常重要的数据类型，如果你说C语言中除了指针，其他你都学得很好，那你干脆说没学过C语言。

void change(int  n)函数调用完毕后，改变实参的值

分析：修改实参的值->找到存储空间->地址

 

指针变量的定义

定义的格式

类名标识符  *指针变量名;

int *p;

先定义后赋值

简单取值

int a = 10;

int *p;

p = &a;

printf(“%d”, *p);

简单改值

*p = 9;

定义的同时赋值

int a = 10;

int *p = &a（此处的*是个象征意义没有特殊含义）;等价于int *p,p=&a

实现修改实参

注意点

int *p;   p = 1000; 指针变量只能存储地址

int *p=100;指针代表指向100；

int *p;  *p = &a;不能把地址给*p,除非是2重指针

%p输出指针里面存储的地址值

其他指针类型说明，比如float *p;  char *p;

不能乱用类型，比如int a = 10;  float *p = &a;只能指向float型变量。

清空指针

p = 0;

p = NULL;

 

指针实例 

void swap(char *a, char *b)  （注意temp=a;  a = b; b = temp;）

int sumAndMinus(int a, int b, int *minus)

 

指针探究

指针变量所占用的存储空间

long *bp;printf(“bp=%zd\n”, sizeof(bp)); zd对应unsigned long.指针8字节

为何指针变量要分类型？

int i = 2;

char c = 1;

int *p = &c;

printf(“%d”, *p);

 

指针与数组

指向一维数组元素的指针：指向数组的首元素

用指针遍历一维数组元素：*(p+2)=p[2]=a[2]

P+1加的地址多少取决于指针的类型；

*(p+i)和*(p++)的区别：前者取的是p[i],后者是p[i-1]

 

指针与字符串

字符串char s[] = “mj”;字符串变量

指针char *s = “mj”;或者char *s;s = “mj”;字符串常量

 

#include <stdio.h>

/*

 1.常量区

 存放一些常量字符串

2.堆

 对象

3.栈

 存放局部变量

掌握：

 定义字符串的2种方式

 1> 利用数组

 char name[] = "itcast";

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

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

2> 利用指针

  char *name = "itcast";

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

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

 */

int main()

{

    char name[20];

    printf("请输入姓名：\n");

    scanf("%s", name);

    // 'j' 'a' 'c' 'k' '\0'

    //printf("%c\n", name[3]);

    //printf("刚才输入的字符串是：%s\n", name);

    return 0;

}

// 定义字符串数组

void test2()

{

    char *name = "jack";

    //int ages[5];

    // 指针数组（字符串数组）

    char *names[5] = {"jack", "rose", "jake"};

    // 二维字符数组（字符串数组）

    char names2[2][10] = {"jack", "rose"};

}

// 定义字符串

void test()

{

    // 字符串变量

    char name[] = "it";

name[0] = 'T';

//printf("%s\n", name);

    // "it" == 'i' + 't' + '\0'

    // 指针变量name2指向了字符串的首字符

    // 字符串常量

    char *name2 = "it";

    char *name3 = "it";

    //*name2 = 'T';

    //printf("%c\n", *name2);

    printf("%p\n%p\n", name2, name3);

    //printf("%s\n", name2);

}

习题

编写一个int string_len(char *s)，返回字符串s的字符长度

 #include <stdio.h>

/*

 (不包括\0)

 编写一个int string_len(char *s)，返回字符串s的字符长度

 

 */

int string_len(char *s);

 

int main()

{

    //char *name = "itcast";

   

   // 男 \u434\u4343\u434

   

    int size = string_len("tre777");

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

    return 0;

}

int string_len(char *s)

{

    // 1.定义一个新的指针变量指向首字符

    char *p = s;

    /*

    while ( *s != '\0' )

    {

        s++;

    }*/

    while ( *s++ ) ;

    return s - p - 1;

}

/*

int string_len(char *s)

{

    // 记录字符的个数

    int count = 0;

    // 如果指针当前指向的字符不是'\0'

    // 首先*s取出指向的字符

    // 然后s++

    while ( *s++ )

    {

        // 个数+1

        count++;

        // 让指针指向下一个字符

        //s = s + 1;

        //s++;

    }

    return count;

}

*/

/*

int string_len(char *s)

{

    // 记录字符的个数

    // 如果指针当前指向的字符不是'\0'

    while ( *s != '\0')

    {

        // 个数+1

        count++;

        // 让指针指向下一个字符

        //s = s + 1;

        s++;

    }

    return count;

}*/

 

返回指针的函数只要求能看懂

指针也是C语言中的一种数据类型，因此一个函数的返回值肯定可以是指针类型的

返回指针的函数的一般形式为：类型名 * 函数名(参数列表)

main()

{

    Char *name =test()

}

 Char *test()

{

    Return “rose”;

}

指向函数的指针

为什么指针可以指向一个函数？

函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址，即函数的入口地址。函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。因此，可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。

指向函数的指针的定义

定义的一般形式：函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);

Void (*p)();

可以比如说用p()间接调用test函数p=test即可；

使用注意

由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的

指向函数的指针变量主要有两个用途：

·  调用函数

·  将函数作为参数在函数间传递

掌握

1.    看懂语法

2.    定义指向函数的指针

  double (*p)(double,char*,int);p=haha;

double (*p)(double,char*,int)=haha;

3.    如何间接调用函数

1>    p(10.7,”jack”,10)

2>    (*p)( 10.7,”jack”,10))