二维数组：首先确定第一行然后将第一行的列填满，再进行第二行，然后再将第二行的列填满,若不够的系统默认以0补上
如a[2][3] = {1,2,3,4,5};
结果为
1 2 3
4 5 0
例如
void main()
{
int a = 1;
int *p = &a;//是定义int *类型的p， 并给p初始化为&a。 等效于int *p;
*p = &a;//是把a的地址赋值给*p, p需要是int **类型
p = &a;//把a的地址，赋值给p， p需要是int *类型,是给p赋值，而不是给*p赋值
pirntf("%d",*p);
printf("%d",p);
display: 1 1638212// 显示*p与p的结果
定义指针的类型需要与变量的类型一致，因为编译器需要知道一个指针移动时的步长
int * 是指向int类型的指针；
int **，也即(int *) *，是指向int *类型的指针，也就是指向指针的指针；
int ***，也即(int **) *，是指向int**类型的指针，也就是指向指针的指针的指针；
不管什么类型，只要是指针 长度就是4个字节；
int *a[] ={1,2,3,4};
int i;
for(i = 0;i<4;i++)
{
printf("%d
",*(a+i));
printf("%d
",a+i);
}
return 0;
display: 1 2 3 4//显示*（a+i）
display:2686716 2686720 2686724 2686728显示（a+i）
}
一个指针是一个地址，是一个常量，一个变量的地址称为这个变量的指针
如果有一个变量专门用来存放另一个变量的指针，则称为指针变量，如：定义指针*p=&a,说明p是一个指针变量。
int main(int argc, char *argv[]) {
int a = 10;
int b = 20;
int *p = &a;
printf("%d
",*p); //代表a的数值 使用p进行间接访问
*p = 40; //对a地址里的内容进行操作
printf("%d
",a);
printf("%d",p); //代表a的地址
return 0;
}
运行结果
指针所占据的空间由操作系统的位数决定如64位操作系统，那么指针所占据的空间就是8K
数组作为函数参数（在ｓｃｏｒｅ大于等于90的姓名后面加上Ａ）
typedef struct stu
{
char name[40];
char sex;
int score;
}student;
void mark(student *p,int count) //指针可以当数组用，数组可以当指针用
{
int i;
for(i = 0;i<count;i++)
{
if(p[i].score >= 90) //p[i].score中的p要与所定义的指针变量一致，p[i].score指的是结构体中的stu1[].score
{
strcat(p[i].name,"(A)");
}
}
}
void prin(student *arry,int coun)
{
int j = 0;
for(j = 0;j<coun;j++)
{
printf("%s %d ",arry[j].name,arry[j].score);
}
}
int main(int argc, char *argv[]) {
student stu1[5] = {
{"wangwu",'m',95},
{"lisi",'m',92},
{"zhangsan",'m',46},
{"xiaolin",'m',85},
{"zhaogou",'m',90}
};
prin(stu1,sizeof(stu1)/sizeof(stu1[0]));
mark(stu1,sizeof(stu1)/sizeof(stu1[0]));
prin(stu1,sizeof(stu1)/sizeof(stu1[0]));
return 0;
}
运行结果
打印出一个字符串里有多少个ａ并将ａ换成Ａ
方法一：
void arr(char *st,int count)
{
int number = 0;
int i;
for(i = 0;i<count;i++)
{
while(st[i] != ' ')
{
if(st[i]=='a')
{
number++;
st[i] = 'A';
}
st++;
}
}
printf("%d＼ｎ",number);
}
int main(int argc, char *argv[]) {
char str[] = "happy new yeaaaaar";
arr(str,sizeof(str)/sizeof(str[0]));
printf("%s",str);
return 0;
}
方法二：
void arr(char *st)
{
int number = 0;
while(*st != ' ')
{
if(*st == 'a')
{
number++;
*st = 'A';
}
st++;
}
printf("%d
",number);
}
int main(int argc, char *argv[]) {
char str[] = "happy new yeaaaaar";
arr(str);
printf("%s",str);
return 0;
}
运行结果
将数值大于20 的清零
void arr(int *p,int count)
{
int i;
for(i = 0;i<count;i++)
{
printf("%d ",p[i]);
}
printf("
");
}
void prin(int *p,int count,int min)
{
int j;
for(j = 0;j<count;j++)
{
if(p[j]>min)
p[j] = 0;
printf("%d ",p[j]);
}
}
int main(int argc, char *argv[]) {
int number[] = {1,2,6,8,9,7,12,63,54};
arr(number,sizeof(number)/sizeof(number[0]));
prin(number,sizeof(number)/sizeof(number[0]),20);
return 0;
}
运行结果
static函数
静态变量 相当于在函数内部定义了一个局部变量
比如：
void test()
{
static int i = 1;
printf("%d
",i++);
}
int main(int argc, char *argv[]) {
test();
test();
test();
return 0;
}
test函数开设了一个静态变量 i 并赋初值1，这个变量在main函数还没运行就创建好了 ，程序运行多次调用test函数时并不会重新赋值，而是将 i 运行之后的值置为当前值
运行结果
int main(void) {
int *a[10]; //指针数组，表示同时创立了10个指针
int b,c;
a[2] = &b; //第二个指针指向的元素
a[3] = &c; //第三个指针指向的元素
b = 10;
c = 20;
printf("b = %d,c = %d
",*a[2],*a[3]); //打印b与c两个元素的值
printf("b = %d,c = %d",a[2],a[3]); //打印b与c两个元素的地址
运行结果
int a[] = {1,2,3,4};
int *p = &a; //对于数组来说*p=a与*p=&a与p=a是一样的都是指向数组首地址
//int *p;
//p = a;
//数组名与指针 指针可以当数组用，数组可以当指针用
int a[] = {1,2,3,4};
int *p = a;
printf("%d
",*(++p));//指向第1个元素
printf("%d
",*(p+1));//在运行*(++p)后再运行*(p+1)，此时指向的是第二元素
printf("%d
",*(a+1));//指向第一个元素
/*(a+1)与*(p+1)是一样的，指的是指向第一个元素因为*a与*p指向了数组首地址也就是第0个元素
*（p++）只能一次加一，就是说一次只能往下移动一个元素
*(a+1)与*(p+1)可以指定移到哪个元素
注：*（a++）不成立，因为a是数组是只可以读取而不可以更改的，指针是可读可更改的 ，而*（a+1）则成立*/
运行结果
