作用域和存储类型
作用域：变量的作用范围，每一个变量都有一个作用域，变量在自己的作用域内是有效的，离开自己的作用域后就无效
1:文件作用域：变量定义开始到文件结束
例子：全局变量
全局变量：函数外定义的变量
2:函数作用域：函数体中有效
例子：函数的形参
3:块｛｝作用域：变量定义开始，到｝结束
例子：局部变量
局部变量：函数体中定义的变量
#include <stdio.h>
int c = 0;//全局变量，具有文件作用域
void add(int a, int b)//a,b函数行参，具有函数作用域
{
return a+b;
}
int d = 0;
int main(int argc, const char *argv[])
{
int e = 0;//局部变量，具有块作用域
return 0;
}
#include <stdio.h>
int main(int argc, const char *argv[])
{
for (int i=0; i<5; i++){
printf("i = %d\n", i);
}
printf("i = %d\n", i);//i是局部变量，具有块作用域
return 0;
}
同名标识符隐藏规则：就近原则
#include <stdio.h>
int a = 0;
int main(int argc, const char *argv[])
{
int a = 3;
printf("a = %d\n", a);
return 0;
}
变量的完整定义：
修饰符 存储类型 符号类型 数据类型 变量名
变量：存储数据
数据类型：决定了变量的大小
符号类型：决定最高位用来保存数据还是符号
存储类型：变量保存在哪里
1:自动存储auto：内存栈中
2:静态存储static：数据段
3:寄存器存储register：寄存器中
4:外部声明extern：只是声明变量，没有开辟存储空间
修饰符：const，volatile
内存分布图：
#include <stdio.h>
#include <stdlib.h>
int b = 0;//已经初始化的全局变量
static int c = 0;//已经初始化的static修饰的变量
int e;//未始化的全局变量
static int f;//未初始化的static修饰的变量
int main(int argc, const char *argv[])
{
//只读存储区
char *a = "abcd";
static int d = 0;//已经初始化的static修饰的变量
static int g;//未初始化的static修饰的变量
char *h = malloc(10);//堆
int i = 0;//局部变量,栈
printf("只读存储区 = %p\n", a);
printf("已经初始化的全局变量 = %p\n", &b);
printf("已经初始化的static修饰的变量 = %p\n", &c);
printf("已经初始化的static修饰的变量 = %p\n", &d);
printf("未初始化的全局变量 = %p\n", &e);
printf("未初始化的static修饰的变量 = %p\n", &f);
printf("未初始化的static修饰的变量 = %p\n", &g);
printf("堆 = %p\n", h);
printf("栈 = %p\n", &i);
return 0;
}
特点：
栈：局部变量，栈上的空间是由系统自动开辟，并且由系统自动释放（当发生函数调用时，系统会为局部变量在栈上开辟空间，函数调用结束后自动释放）
堆：程序员通过malloc开辟，free释放（整个程序运行结束后由系统释放，不建议）
数据段：数据段上数据在整个程序运行过程中一直存在，当程序结束后由系统释放
1、什么是地址（指针）
scanf——>&取出变量地址
数组名——>地址常量，等于数组首元素的地址
函数名——>地址常量，等于函数的入口地址
什么是地址？
内存中最小的单位是字节
2的64次方
地址：内存中每个字节前面都有一个编号，这个编号就是地址
变量的地址：变量在内存中某个字节的编号
什么是指针：地址就是指针，指针就是地址
2、如何去保存（指针）
思考：
整数——>整型变量
字符——>字符变量
指针——>指针变量
结论：通过指针变量来保存指针
3、指针变量的定义
格式：数据类型 ＊变量名；
变量名：满足标识符命名规则
＊：表示该变量是一个指针变量
数据类型：指针所指向的变量的数据类型
为什么要这样定义？
变量名：变量的名字
＊：表示该变量是指针变量
数据类型：
1:决定该指针所能指向的变量的数据类型
2:当指针指向一个数组时，数据类型决定指针加1（p+1），1的大小
int arr[5];
int *p = &arr[0];
p+1——>4个字节
char buf[10];
char *p = &buf[0]
p+1——>1个字节
int a = 0;
int (*p) = &a;
练习：
定义出两个指针变量，分别指向整型变量和字符型变量
int c＝0；int ＊a＝&c；
char d＝‘e‘；char ＊b＝&d；
4、指针变量的大小
计算方式：sizeof（变量名）
char ＊p＝NULL；sizeof（p）； 大小8个字节
int ＊p＝NULL；sizeof（p）； 大小8个字节
#include <stdio.h>
int main(int argc, const char *argv[])
{
int a = 0;
char ch = 0;
int *pa = &a;
char *pCh = &ch;
printf("sizeof(pa) = %lu\n", sizeof(pa));
printf("sizeof(pCh) = %lu\n", sizeof(pCh));
return 0;
}
指针变量的大小：指针变量的大小是由当前操作系统位数决定64位操作系统下的指针变量都是8个字节（32位是4个字节）
5、指针变量的赋值
1：初始化
int a＝0；
int ＊p＝&a；
2：赋值语句
int a＝0；
int ＊p＝NULL；
p＝&a；
练习：定义出两个指针变量，分别指向整型变量和字符型变量，分别使用初始化和赋值语句的方式对变量进行赋值
6、指针变量的作用
1:保存指针
2:另一种操作数据的方式
#include <stdio.h>
int main(int argc, const char *argv[])
{
int a = 5;
int *pa = &a;
printf("&a = %p\n", &a);
printf("pa = %p\n", pa);
printf("a = %d\n", a);
printf("*pa = %d\n", *pa);
return 0;
}
`
7、与指针相关的基本操作
1:&
作用：取出变量的地址
2:＊
1:＊地址＝
作用：向该地址中存数据
2:＝＊地址
作用：从该地址中取数据
3:p+n：当p指向一个数组时，p＋1指向下一个元素
p——>&arr[0]
p+1——>&arr[1]
#include <stdio.h>
#define NUM 5
int main(int argc, const char *argv[])
{
int arr[NUM] = {};
int (*p) = &arr[0];
int i = 0;
for (i=0; i<NUM; i++){
printf("&arr[%d] = %p\n", i, &arr[i]);
printf("p+%d = %p\n", i, p+i);
}
return 0;
}
4:p－q：p和q指向同一个数组
int arr[5];
int *p = &arr[0];——>p+0
int *q = &arr[4];——>p+4
q-p————>4———>p和q之间相隔元素的个数
#include <stdio.h>
#define NUM 5
int main(int argc, const char *argv[])
{
int arr[NUM] = {};
int *p = &arr[0];
int *q = &arr[4];
printf("q - p = %ld\n", q-p);
return 0;
}
5:关系运算（p,q,p>q,p<q,p>=q,p<=q,p==q,p!=q）
#include <stdio.h>
#define NUM 5
int main(int argc, const char *argv[])
{
int arr[NUM] = {1, 2, 3, 4, 5};
int *p = NULL;
for (p=arr; p<(arr+5); p++){
printf("*p = %d\n", *p);
}
return 0;
}
8、指针和其他数据类型的结合
1:指向基本数据类型变量的指针
例子：
int a = 3;
int *p = &a;
printf(“a = %d\n”, a);
prntf(“*p = %d\n”, *p);
两个数的交换
int a = 3;
int b = 5;
int *pa = &a;
int *pb = &b;
int tmp = 0;
#include <stdio.h>
int main(int argc, const char *argv[])
{
int a = 3;
int b = 5;
int *pa = &a;
int *pb = &b;
int *pTmp = NULL;
int tmp = 0;
printf("a = %d\n", a);
printf("b = %d\n", b);
#if 0
tmp = a;
a = b;
b = tmp;
#endif
#if 0
tmp = *pa;
*pa = *pb;
*pb = tmp;
#endif
pTmp = pa;
pa = pb;
pb = pTmp;
printf("*pa = %d\n", *pa);
printf("*pb = %d\n", *pb);
// printf("a = %d\n", a);
// printf("b = %d\n", b);
return 0;
}
2:指向数值型数组首元素的指针
1:指向数组首元素指针的定义
例子：int arr[5];//arr等价于&arr[0]
初始化:
int *p = &arr[0];//int *p = arr;
赋值语句:
int *p = NULL;
p = &arr[0];//p = arr;
2:数组成员的引用：//p等价于arr
下标法：arr[i], p[i]
指针法: *(arr+i), *(p+i)
思考：arr和p是否完全等价
数组名是一个地址常量，不能够被修改(arr++不可以的)
指针变量是一个地址变量，可以被修改(p++可以的)
int arr[5];
int brr[5];
int *p = arr;
{
p操作arr
}
p = brr;
{
p操作brr
}
定义一个数组并初始化，用四种方式打印数组成员的值
#include <stdio.h>
#define NUM 5
int main(int argc, const char *argv[])
{
int arr[NUM] = {1, 2, 3, 4, 5};
int *pArr = arr;
int i = 0;
for (i=0; i<NUM; i++){
printf("%d ", arr[i]);
}
printf("\n");
for (i=0; i<NUM; i++){
printf("%d ", pArr[i]);
}
printf("\n");
for (i=0; i<NUM; i++){
printf("%d ", *(arr+i));
}
printf("\n");
for (i=0; i<NUM; i++){
printf("%d ", *(pArr+i));
}
printf("\n");
return 0;
}
练习：
1：找出数组arr中值最大的数组成员，打印值（比较和查找）
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NUM 10
int main(int argc, const char *argv[])
{
int arr[NUM] = {};
int i = 0;
int max = 0;
srand(time(NULL));
for (i=0; i<NUM; i++){//输入
*(arr+i) = rand()%100;
printf("%d ", *(arr+i));
}
printf("\n");
for (max=*(arr+0),i=0; i<NUM; i++){
if (max < *(arr+i)){
max = *(arr+i);
}
}
printf("max = %d\n", max);
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10
int main(int argc,
const char * argv[])
{
int a[N]={};
int *p=a;
int i,k=0;
srand(time(NULL));
for (; p<(a+N); p++) {
*p=rand()%100;
printf("%d ",*p);
}
printf("\n");
p=a;
for (; p<(a+N); p++) {
if (*p>k) {
k=*p;
i=p-a;
}
}
printf("%d %d\n",k,i);
}
2：冒泡排序（排序）
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NUM 10
int main(int argc, const char *argv[])
{
int arr[NUM] = {};
int i = 0;
int tmp = 0;
int j = 0;
srand(time(NULL));
for (i=0; i<NUM; i++){//输入
*(arr+i) = rand()%100;
printf("%d ", *(arr+i));
}
printf("\n");
for (j=0; j<NUM; j++){//冒泡执行的次数
for (i=0; i<NUM-1; i++){//相邻成员比较
if (*(arr+i) > *(arr+i+1)){//交换
tmp = *(arr+i);
*(arr+i) = *(arr+i+1);
*(arr+i+1) = tmp;
}
}
}
for (i=0; i<NUM; i++){//输入
printf("%d ", *(arr+i));
}
printf("\n");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10
int main(int argc,
const char * argv[])
{
int a[N]={};
int *p=a;
int i,j,k=0;
srand(time(NULL));
for (; p<(a+N); p++) {
*p=rand()%100;
printf("%d ",*p);
}
printf("\n");
p=a;
for (i=0; i<N; i++) {
for (j=0; j<N-i-1; j++) {
if (*(p+j)>*(p+j+1)) {
k=*(p+j);
*(p+j)=*(p+j+1);
*(p+j+1)=k;
}
}
}
for (; p<(a+N); p++) {
printf("%d ",*p);
}
printf("\n");
}
3：将数组a中的成员按相反顺序存放（逆序）
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define NUM 10
int main(int argc, const char *argv[])
{
int arr[NUM] = {};
int i = 0;
int tmp = 0;
srand(time(NULL));
for (i=0; i<NUM; i++){//输入
*(arr+i) = rand()%100;
printf("%d ", *(arr+i));
}
printf("\n");
for (i=0; i<(NUM/2); i++){//逆序
tmp = *(arr+i);//交换
*(arr+i) = *(arr+NUM-1-i);
*(arr+NUM-1-i) = tmp;
}
for (i=0; i<NUM; i++){//输入
printf("%d ", *(arr+i));
}
printf("\n");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define N 10
int main(int argc,
const char * argv[])
{
int a[N]={};
int *p=a;
int i=0,k=0;
srand(time(NULL));
for (; p<(a+N); p++) {
*p=rand()%100;
printf("%d ",*p);
}
printf("\n");
p=a;
for (; p<(a+N/2); p++) {
k=*p;
*p=*(p+N-i-i-1);
*(p+N-i-i-1)=k;
i++;
}
p=a;
for (; p<(a+N); p++) {
printf("%d ",*p);
}
printf("\n");
}
4：在有序的数组中插入整数n
5：在有序的数组中删除整数n
3:指向字符型数组首元素的指针
字符串的常见表示形式：
1:字符数组保存字符串
例子：char buf[5] = “abcd”;
2:指向字符串首地址的指针
例子：char *p = “abcd”;
3:指向数组首元素的指针
例子：char buf[5] = “abcd”;char *p = buf;
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
#if 0
char buf[SIZE] = "abcd";
buf[0] = ‘h‘;
printf("%s\n", buf);
char *p = "abcd";
*p = ‘h‘;//"abcd"是字符串常量，不能被修改
printf("%s\n", p);
#endif
char buf[SIZE] = "abcd";
char *p = buf;
buf[0] = ‘h‘;
p[1] = ‘S‘;
printf("%s\n", buf);
printf("%s\n", p);
return 0;
}
1：实现字符串处理函数strlen
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
int i = 0;
gets(buf);
for (i=0; *(buf+i); i++);
printf("i = %d\n", i);
return 0;
}
3：实现字符串处理函数strcat
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf1[SIZE] = "";
char buf2[SIZE] = "";
int i = 0;
int j = 0;
gets(buf1);
gets(buf2);
for (i=0; *(buf1+i); i++);
for (j=0; *(buf2+j); j++){
*(buf1+i+j) = *(buf2+j);
}
printf("buf1 = %s\n", buf1);
printf("buf2 = %s\n", buf2);
return 0;
}
4：实现字符串处理函数strcpy
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf1[SIZE] = "";
char buf2[SIZE] = "";
int i = 0;
gets(buf2);
for (i=0; *(buf2+i); i++){
*(buf1+i) = *(buf2+i);
}
printf("buf1 = %s\n", buf1);
printf("buf2 = %s\n", buf2);
return 0;
}
5：实现字符串处理函数strcmp
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf1[SIZE] = "";
char buf2[SIZE] = "";
int i = 0;
int j = 0;
gets(buf1);
gets(buf2);
for (i=0; *(buf1+i) && *(buf2+i); i++){
if (*(buf1+i) != *(buf2+i)){
break;
}
}
printf("*(buf1+%d)-*(buf2+%d) = %d\n", i, i, *(buf1+i)-*(buf2+i));
return 0;
}
6：实现字符串处理函数strchr
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
char ch = 0;
int i = 0;
gets(buf);
ch = getchar();
for (i=0; *(buf+i); i++){
if (*(buf+i) == ch){
break;
}
}
if(*(buf+i)==0){
printf("null\n");
} else {
printf("%s\n", buf+i);
}
return 0;
}
8:给定一个英文句子，单词之间用1个空格分开，求其中所有单词的数量
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
int i = 0;
int t = 0;
gets(buf);
for (i=0; *(buf+i); i++){
if (*(buf+i) == ‘ ‘){
t++;
}
}
printf("t = %d\n", t+1);
return 0;
}
a b c d e f
p = strchr , p++
#include <stdio.h>
#include <string.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
char *p = NULL;
int t = 0;
gets(buf);
for (p=buf; (p=strchr(p, ‘ ‘)); t++, p++);
printf("t = %d\n", t+1);
return 0;
}
9:删除字符串中的数字字符
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
int i = 0;
int j = 0;
gets(buf);
for (i=0; *(buf+i); i++){//遍历buf
if ((*(buf+i)>=‘0‘) && (*(buf+i)<=‘9‘)){//在buf中找到数组字符
for (j=i; *(buf+j); j++){//循环前移
*(buf+j) = *(buf+j+1);
}
i--;//重复
}
}
printf("buf = %s\n", buf);
return 0;
}
10:将字符串中连续出现的空格（两个以上）合并成一个
strstr(p, “ ”)
a******b
#include <stdio.h>
#include <string.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
char *p = buf;
char *pCp = NULL;
int i = 0;
int j = 0;
gets(buf);
for (; (p = strstr(p, " ")); p++){//遍历连续空格
for (pCp=p; *(pCp); pCp++){//循环前移
*pCp = *(pCp+1);
}
p--;//重复
}
printf("buf = %s\n", buf);
return 0;
}
11:找出字符串中首次只出现一次的字符
abcabc
abcdabc
flag = 1;
if (flag == 1){
break;
}
#include <stdio.h>
#define SIZE 100
int main(int argc, const char *argv[])
{
char buf[SIZE] = "";
int i = 0;
int j = 0;
int flag = 0;
gets(buf);
for (i=0; *(buf+i); i++){//取出buf中的每个字符
for (j=0, flag=0; *(buf+j); j++){//查找每个字符出现的次数
if (*(buf+i) == *(buf+j)){
flag++;//计数
}
}
if (flag == 1){//判断出现的次数
break;
}
}
if (*(buf+i) == 0){
printf("没有\n");
} else {
printf("%c\n", *(buf+i));
}
return 0;
}
4:指向指针的指针
int a = 3;
int (*p) = &a;
int *(*pp) = &p;
int **(*ppp) = &pp;
printf(&a);
printf(p);
printf(*pp);
printf(**ppp);
printf(a);
printf(*p);
printf(**pp);
printf(***ppp);
#include <stdio.h>
int main(int argc, const char *argv[])
{
int a = 3;
int *p = &a;
int **pp = &p;
int ***ppp = &pp;
printf("&a = %p\n", &a);
printf("p = %p\n", p);
printf("*pp = %p\n", *pp);
printf("**ppp = %p\n", **ppp);
printf("a = %d\n", a);
printf("*p = %d\n", *p);
printf("**pp = %d\n", **pp);
printf("***ppp = %d\n", ***ppp);
return 0;
}
5:指向函数的指针
6:指向结构体变量的指针
7:指向结构体数组的指针
9、const修饰指针
常见const修饰的指针：
1:const int *p;//*p不能变
2:int const *p;//*p不能变
3:int *const p;//p不能变
4:const int *const p;//*p和p都不能变
const修饰谁谁不能变
const离谁近谁就不能变
10、指针数组
思考：
大量整型变量———>整型数组
大量字符变量———>字符数组
大量指针变量(指向的变量的数据类型相同)———>指针数组
指针数组：本质是数组，数组的成员是指针
int *pArr[5];
pArr——>&pArr[0]
指针数组的定义：
格式：数据类型 *数组名[常量];
数组名：地址常量，等于数组首元素的地址，数组名是二级指针
常量：数组成员的个数
数据类型 *:数组成员的类型
数据类型：数组成员指向变量的数据类型
例子：
int *pArr[5] = {int*p0, int *p1…..};
int *
int
练习：
1：通过比较，找出五个字符串中最大的字符串并输出
char *pArr[5] = {“bei”, “jing”, “huan”,”ying”, “nin”}
char buf0[100] = “bei”;
char buf1[100] = “jing”
……
char *pArr[5] = {buf0, buf1, buf2, buf3, buf4};
char *pMax = pArr[0];
if (strcmp(pMax, pArr[i]) < 0){
pMax = pArr[i];
}
printf(“%s”, pMax);
#include <stdio.h>
#include <string.h>
#define NUM 5
int main(int argc, const char *argv[])
{
char *pArr[NUM] = {"bei", "jing", "huan", "ying", "nin"};
char *pMax = NULL;
int i = 0;
for (pMax=pArr[0],i=0; i<NUM; i++){//遍历数组
if (strcmp(pMax, pArr[i]) < 0){//将pMax和数组成员比较
pMax = pArr[i];
}
}
printf("pMax = %s\n", pMax);
return 0;
}
2：实现五个字符串的排序
#include <stdio.h>
#include <string.h>
#define NUM 5
int main(int argc, const char *argv[])
{
char *pArr[NUM] = {"bei", "jing", "huan", "ying", "nin"};
int i = 0;
char *pTmp = NULL;
int j = 0;
for (j=0; j<NUM; j++){
for (i=0; i<(NUM-1); i++){//冒泡
if (strcmp(pArr[i], pArr[i+1]) > 0){//相邻成员比较
pTmp = pArr[i];//交换
pArr[i] = pArr[i+1];
pArr[i+1] = pTmp;
}
}
}
for (i=0; i<NUM; i++){
printf("%s\n", pArr[i]);
}
return 0;
}
11、malloc和free
malloc在堆上开辟存储空间
free释放存储空间，把该存储空间的使用权还给系统
数据类型 数组名[常量];
数组名:数组首元素的地址
int arr[5];//可以//栈上开辟了一个数组，数组成员5个每个成员大小4个字节
int n;
scanf(“%d”, &n);
int arr[n];//不可以的
int *pArr = malloc(sizeof(int)*5);//4*5
int n = 0;
scanf(“%d”, &n);
int *pArr = malloc(sizeof(int)*n);//可以的
char *p = malloc(sizeof(char)*100);
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(int argc, const char *argv[])
{
int n = 0;
scanf("%d", &n);
char *p = malloc(sizeof(char)*n);
strcpy(p, "bei jing huan ying nin");
printf("p = %s\n", p);
return 0;
}
课后练习：（指针实现）
1.
给定某个字符数组，统计数组中所有英文字符的个数，比如“123fdd”中有3个。
2.
给定某个字符数组，统计数组中所有英文字符和阿拉伯数字的个数，比如“123fdd”中有英文字符有3个，数字3个。
3.
给定某个拥有5个元素的字符数组，数组的成员都有阿拉伯字符构成，试着将该数组转换成一个整数，比如字符数组的内容是：{‘1’,’2’,’3’,’3’,’2’}
则将被转换成12332。
4.
给定一个完全由英文字符构成的数组，将数组中的小写字母转换成大写字母，大写字母转换成小写字母并输出。例如“abcGGG”转化为“ABCggg”。
5.
给定一个完全由英文字符构成的数组，将数组中下标为偶数的字符都转换为大写（如果原来是大写则不变）。
6.
给一个完全由英文字符构成的字符数组加密，加密原则如下，除了字符‘Z’和‘z’之外，每个字符变成ASCII码值比它大1的字符，也就是‘A’变成‘B’。‘Z’或者‘z’转化为‘A’或者‘a’。
7.
计算某个由英文、数字以及标点符号构成的数组的总宽度，其中英文字符的宽度为1cm，数字宽度为0.5cm、标点符号宽度为0.8cm。
8.
接上题，如果规定行的宽度为10cm，将某个字符长度超过50的字符串截断，恰好使10cm宽的行能容纳。输出这个被截断的子数组。
9.
给定某个整型数组，计算该数组所有偶数的合。
10.
给某个整型数组赋值，赋值规律如下，下标能被3整除的都赋值为1，能被5整除的都赋值为2，能被7整除的都赋值为3，其余都赋值为0.
11.
通过终端输入10个整数并将其保存在一个整型数组中，数字保存在数组中的顺序与下标正好相反，也就是第一个被输入的数放在数组最后一个元素中，最后一个输入的数字放到第一个元素中。
12.
通过终端输入10个整数，计算10个整数中所有能被3整除的数的合。
13.
给定一个5个元素构成的整型数组，每个元素的值都在0-9之间，按照位置将其组成一个5位数并输出，例如int
a[5] = {1,2,2,3,7};则输出73221。
14.
给定2个大小一样的整型数组，将某个数组作为源数组，另一个作为目的数组，然后将源数组的内容拷贝到目的数组。
15.
给定一个整型数组，将第一个跟最后一个元素的内容交换。
16.
给定一个整型数组，从第1个元素开始将相邻的两个元素分别相互交换。交换完后，第1个元素将变成最后一个元素，其余元素都前进一位。
17. 给定一个有10个整形数的元素，将前5个元素跟后5个元素做整体交换，比如{1,1,1,1,1,2,3,2,2,2}->{2,3,2,2,2,1,1,1,1,1}。
18. 判断一个整型数组是否是对称数组，例如{1,2,3,3,2,1}和{1,6,8,1,8,6,1}都是对称数组。
19.
给定两个大小一样的整型数组，交换这两个数组的内容。
20.
给定两个大小一样的整型数组，将两个数组中下标一样的元素两两相加，相加后的结果作为这两个数组对应下标的新值，也就是操作完毕后两个数组的内容完全相同。
21.
给定一个能容纳10个元素的整型数组，现有9个元素，现在第5个元素的位置插入一个数字88，后面的数字顺序后移。
22.
给定一个10个元素的整型数组，现在将第2个元素删除，后面的数组顺序前移。
23.
给定一个有100个元素的数组，查询数组中是否有元素的值等于某个数n。
24.
给定一个整型数组，求该数组元素中最大值的下标。
25.
给定一个整型数组，求该数组中第二大的数的下标。
26.
给定一个整型数组，求该数组中数值小于10的元素的个数。
27.
给定一个整型数组，计算大于该数组平均值的元素的个数。
28.
给定一个整型数组，找到数组中的最小值，并将其放到数组的首元素中，原来首元素的内容放到最小值所在的元素中。
29.
给定一个整型数组，统计某个整数在数组中出现的次数。
30.
给定一个英文句子，单词之间用1个空格分开，求出第2个单词的偏移位置。例如“Professor du comes from
Korea”的偏移位置是10。
31.
给定一个英文句子，单词之间用1个空格分开，求其中所有单词的数量。
32.
给定两个字符数组，将这两个拼接起来放在第一个数组中（假定第一个数组足够长），比如“abc”和“123”构成“abc123”。
10:将一个字符串进行逆序
例如：逆序前：abcdefg
逆序后：gfedcba
11: 一个字符串，其中有多个单词，单词之间用空格分开，将每个单词进行逆序
例如：逆序前：abc defg heitf
逆序后：cba gfed ftreh
12输入10个数，找出出现次数最多的数
（如果多个并列，则按数字出现顺序分别输出）
13:有m个人围成一圈，开始顺序报数，报到n退出，问最后剩下的是几号。（从1号开始）
14:将字符串中连续出现的空格（两个以上）合并成一个
课后练习：
1:用数组来处理Fibonacci数列的前20个成员的值。
2:有一篇文章，共有三行文字，每行有80个字符。要求分别统计出其中英文大写字母、小写字母、数字、空格以及其它字符的个数。
3:有一行电文，已按下面的规律译成密码：
A-Z a-z
B-Y b-y
C-X c-x
… …
即第一个字母编程第26个字母，第i个字母编程第(26-i+1)个字母。非字母字符不变，要求编程序将密码译回原文，并输出密码和原文。