2.
数组定义和初始化
类型 数组名
[
数组长度
]; //
注意数组长度必须是常量
(
具体数字
)
int
main
()
{
int
a
=
10
;
//
是初始化
int
b
;
//
随机值
(-858993460),
不是
0
b
=
10
;
//
不是初始化
int
arr
[
10
];
//
定义一个
10
个长度的
int
数组
,
但是没有初始化
,
默认为随机值
(-858993460)
int
brr
[
10
]
=
{
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
};
//
初始化列表
int
crr
[
10
]
=
{
1
,
2
,
3
,
4
,
5
};
//1,2,3,4,5,0,0,0,0,0
初始化一部分则剩余部分为
0(
经常使用
和考试
)
//int drr[10] = {1,2,3,4,5,6,7,8,9,10,11};//error,
数据太多
int
err
[]
=
{
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
};
//
自动推导数组长度
//int frr[a];//error,C99
合法
,
但是
VS
系列编译器都不支持
return
0
;
}
int
main
()
{
int
arr
[
10
];
//
定义长度为
10
的
int
数组
,arr
double
brr
[
5
]
=
{
1.2
,
3.4
,
5.6
};
//
定义长度为
5
的
double
数组
,brr
并初始化为
1.2,3.4,4.5
char
crr
[
10
]
=
{
'a'
,
'b'
,
'c'
};
//
定义长度为
10
的
char
数组
,crr,
并初始化为
'a','b','c'
return
0
;
}
3.
数组使用
通过数组下标访问数组元素
,
例如
arr[3] = 10;
注意数组下标从
0
开始
,
最后一个下标是数组长度
-1,
小心数组越界问题
,
下标可以是变量
int
main
()
{
int
arr
[]
=
{
0
,
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
};
for
(
int
i
=
0
;
i
<
10
;
i
++
)
//
输出
arr
的所有数据
{
printf
(
"%d "
,
arr
[
i
]);
}
printf
(
"\n"
);
return
0
;
}
如何区分数组长度和下标
?
定义时
[]
里面的是长度
,
使用时
[]
里面为下标
.
如何区分定义和使用
?
定义
:
前面有数据类型
.
例如
:int arr[10];
使用
:
前面没有数据类型
.
例如
:arr[3] = 10;
课堂练习
int
main
()
{
int
a
=
10
;
int
arr
[
10
]
=
{
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
};
a
=
20
;
//arr = 20;//error
//arr[3] = 20;
//
把
arr
数组的奇数下标的值
+10,
把
arr
数组偶数下标的值
+20
for
(
int
i
=
0
;
i
<
10
;
i
++
)
{
if
(
i
%
2
==
0
)
//
偶数下标
arr
[
i
]
+=
20
;
else
//
奇数下标
arr
[
i
]
+=
10
;
}
//
输出
arr
的所有内容
for
(
int
i
=
0
;
i
<
10
;
i
++
)
{
printf
(
"%d "
,
arr
[
i
]);
}
/*printf("%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\n",
arr[0],arr[1],arr[2],arr[3],arr[4],arr[5],arr[6],arr[7],arr[8],arr[9]);*/
//
不能使用下面的方法输出
arr
//printf("%d\n",arr);//
这只是输出
arr
的地址
,
不能输出
arr
的数据
//printf("%d",arr[10]);//
越界了
//arr[10] = 0;//
崩溃
,
越界了
return
0
;
}
数组练习
2
int
main
()
//
数组练习
2
{
int
arr
[
10
]
=
{
1
,
2
,
3
,
4
,
5
,
6
,
7
,
8
,
9
,
10
};
int
brr
[
10
];
int
crr
[
10
];
//
把
arr
的值复制到
brr
中
//brr = arr;//error,
数组不能整体赋值
for
(
int
i
=
0
;
i
<
10
;
i
++
)
//
必须一个一个复制
{
brr
[
i
]
=
arr
[
i
];
}
//
把
arr
和
brr
对应下标的值相加存放到
crr
中
,crr=arr+brr
for
(
int
i
=
0
;
i
<
10
;
i
++
)
{
crr
[
i
]
=
arr
[
i
]
+
brr
[
i
];
}
//
输出
brr
for
(
int
i
=
0
;
i
<
10
;
i
++
)
printf
(
"%d "
,
brr
[
i
]);
printf
(
"\n"
);
//
输出
crr
for
(
int
i
=
0
;
i
<
10
;
i
++
)
printf
(
"%d "
,
crr
[
i
]);
printf
(
"\n"
);
return
0
;
}
0
在
C
语言中的表现
0: 0,'\0',false,NULL
都是
0
顺序
(
一般
)
查找
适用没有规律的数据
int
main
()
{
int
arr
[
11
]
=
{
1
,
5
,
9
,
0
,
2
,
46
,
67
,
8
,
90
,
123
,
45
};
printf
(
"
请输入需要查找的值
:\n"
);
int
n
;
//
需要查找的值
scanf
(
"%d"
,
&
n
);
//
找到了输出下标
,
没有找到输出
"
没有找到
"
for
(
int
i
=
0
;
i
<
11
;
i
++
)
{
if
(
arr
[
i
]
==
n
)
{
printf
(
"%d
找到了
,
在
%d
下标
\n"
,
n
,
i
);
return
0
;
}
}
printf
(
"%d
没有找到
\n"
,
n
);
return
0
;
}
折半查找
也称二分查找
,
适用有序的数据
int
main
()
//
作业
:
通过调试改正错误
{
int
arr
[
10
]
=
{
1
,
3
,
5
,
6
,
9
,
10
,
12
,
23
,
34
,
45
};
printf
(
"
请输入需要查找的值
:\n"
);
int
n
;
scanf
(
"%d"
,
&
n
);
int
low
=
0
;
//
起始下标
int
mid
;
//
中间下标
int
high
=
10
-
1
;
//
结尾下标
while
(
low
<
high
)
{
mid
=
(
low
+
high
)
/
2
;
if
(
arr
[
mid
]
==
n
)
//
找到了
{
printf
(
"%d
找到了
,
在
%d
下标
\n"
,
n
,
mid
);
return
0
;
}
else if
(
arr
[
mid
]
<
n
)
//n
更大
,
应该在后面找
{
low
=
mid
;
}
else
//n
更小
,
应该在前面找
high
=
mid
;
}
printf
(
"%d
没有找到
\n"
,
n
);
return
0
;
}
.
字符数组和字符串
字符
:
用单引号包括的一个字符
.
例如
'a','1'
字符数组
:
字符类型的数组
.
例如
char arr[10];
字符串
:
用双引号包括的字符序列
,
可以是
0
个或者多个字符
.
例如
"","abc","12a"
字符串有一个隐藏的
'\0'
作为结尾标记
.
在定义数组时注意长度问题
如果字符数组包含
'\0'
那么它也是字符串
,
如果字符数组不包含
'\0'
那么它不是字符串
printf
(
"%c "
,
crr
[
i
]);
printf
(
"%s\n"
,
crr
);
//
不可以
,crr
不是字符串
return
0
;
}
void
Sort
(
int
arr
[
10
])
//sizeof(arr)/sizeof(arr[0]) .
注意如果
arr
是形参这个不适合
{
printf
(
"%d\n"
,
sizeof
(
arr
)
/
sizeof
(
arr
[
0
]));
//
这就不是长度
,error
}
int
main
()
{
int
arr
[
10
]
=
{
100
,
200
};
printf
(
"%d\n"
,
sizeof
(
arr
)
/
sizeof
(
arr
[
0
]));
//10
Sort
(
arr
);
//1
//sizeof(arr)
整个数组字节数
,sizeof(arr[0])
第一个单元格的字节数
printf
(
"%d,%d\n"
,
sizeof
(
arr
),
sizeof
(
arr
[
0
]));
printf
(
"%d\n"
,
sizeof
(
arr
)
/
sizeof
(
arr
[
0
]));
//arr
数组包含多个单元格
(
长度
)
return
0
;
}
int
main
()
{
char
ch
=
'A'
;
char
arr
[]
=
{
'a'
,
'b'
,
'c'
,
'd'
,
'e'
};
//
是字符数组
,
不是字符串
,
数组长度为
5
char
brr
[
5
]
=
{
'a'
,
'b'
,
'c'
,
'd'
,
'e'
};
//
是字符数组
,
不是字符串
,
数组长度为
5
char
crr
[
10
]
=
{
'a'
,
'b'
,
'c'
,
'd'
,
'e'
};
//
是字符数组
,
是字符串
,
数组长度为
10
char
drr
[]
=
{
"abcde"
};
//
是字符数组
,
是字符串
,
数组长度为
6
char
err
[
10
]
=
"abcde"
;
//
是字符数组
,
是字符串
,
数组长度为
10
//char frr[5] = "abcde";//error,
数组不够存放该字符串
printf
(
"%s\n"
,
arr
);
//%s
输出字符串
,
不是字符串
,
不能正常输出
printf
(
"%s\n"
,
brr
);
//
不是字符串
,
不能正常输出
printf
(
"%s\n"
,
crr
);
//
是字符串
(
末尾有
5
个默认的
0),
能正常输出
printf
(
"%s\n"
,
drr
);
//
是字符串
(
用
""
包括的
),
能正常输出
printf
(
"%s\n"
,
err
);
//
是字符串
(
用
""
包括的
),
能正常输出
printf
(
"%d,%d,%d,%d,%d\n"
,
sizeof
(
arr
)
/
sizeof
(
arr
[
0
]),
sizeof
(
brr
),
sizeof
(
crr
),
sizeof
(
drr
),
sizeof
(
err
));
return
0
;
}
4.
字符串常见操作
1.
字符串长度
所见即所得
,
不包含隐藏的
'\0'.
int
main
()
{
char
str1
[]
=
"abcde"
;
//
这种形式使用的最多
//
计算字符串的长度
.str1->5(
不包含
\0)
所见即所得
//sizeof(str1)-1;//
字符串长度
,
不可以
int
count
=
0
;
//
计数器
for
(
int
i
=
0
;
str1
[
i
]
!=
'\0'
;
i
++
)
count
++
;
printf
(
"str1
的长度为
%d\n"
,
count
);
return
0
;
}
\0'
是字符串的结尾
,
注意下面代码的结果
int
main
()
//
考试经常出现
{
char
str
[]
=
"abc\0de\n"
;
//str
数组占用几个单元格
?
字符串多长
? 8,3
printf
(
"%d,%s\n"
,
sizeof
(
str
),
str
);
//8,abc
return
0
}
2.
字符串复制
把一个字符串的内容复制到另一个字符数组中
int
main
()
//
字符串复制
{
char
str1
[]
=
"abcde"
;
char
str2
[
10
];
//str2=str1;//
把
str1
的内容复制到
str2
int
i
;
for
(
i
=
0
;
str1
[
i
]
!=
'\0'
;
i
++
)
str2
[
i
]
=
str1
[
i
];
str2
[
i
]
=
'\0'
;
//
加结尾标记
printf
(
"str2=%s\n"
,
str2
);
return
0
;
}