数组的基本概念
数组是构造类型。
数组就是用来存储一组数据的
数组的特点
只能存放一种类型的数据,比如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))