#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void main22()
{
//数组的初始化
//
int i=0;
int a[10]={1,2};//a 代表数组首元素的地址，不是数组的地址
//&a 表示整个数组的地址 &a a代表的数组类型不一样
//&a 代表数组类型
//a 数组首元素类型
int b[]={1,2};//
int c[20]={0};// 编译期间搞定
//printf("%d\n",sizeof(a));
for(i=0;i<10;i++)
{
printf("%d",a[i]);
}
memset(a,0,sizeof(a));
system("pause");
//1,数组首元素的地址和数组地址是两个不同的概念
//2,数组名代表数组首元素的地址，它是个常量
//解释：变量本质是内存空间的别名，一定义数组，就分配内存，内存就固定了。
//所以数组名起名以后就不能被修改了
//3,数组首元素的地址和数组地址值相等
//4,怎么样得到整一维数组地址
}
void main()
{
//我声明了一个数组类型
int i=0;
typedef int(MyArra5)[5];
int a;
//用数组类型定义一个变量
MyArra5 arr5;//相当于int arra[5];
for(i=0;i<5;i++)
{
arr5[i]=i+1;
}
for(i=0;i<5;i++)
{
printf("%d \n",arr5[i]);
}
printf("%d\n",sizeof(arr5));//20
//解决指针步长问题
printf("%d %d\n",&arr5,&arr5+1);//相差20
system("pause");
}
数组指针
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void main()
{
int a;
int i=0;
int *p=NULL;
int c[5]={1,3,4,55,6 };
//声明了一个数组类型 （固定大小内存块的别名）
typedef int(MyARR5)[5];
//定义一个指向数组类型的指针变量
MyARR5* pArray;// 没有内存就没有指针
{
int i=0;
int *pi=&i;
}
{
//a1 代表数组首元素的地址（不是整个数组的地址）请问a1 指针变量 a1 是常量
//a1->变量-->指针变量->常量指针变量
// 结论:不能被随便的改变指针变量的值（不能随便改变指针的指向）
//为什么它是一个const ?
//
int a1[5]={1,3,4,55,6};
MyARR5 *pArray=&a1;
//用数组指针去遍历数组
for(i=0;i<5;i++)
{
printf("%d..\n",(*pArray)[i]);
}
}
}
//源码教师
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
int get(char *const p)
{
}
/*
typedef struct _Teacher
{
char name[64];
int age ;
}Teacher, *pTeacher;
pTeacher t1;
*/
void main()
{
int a;
int *p = NULL;
int i = 0;
//我声明了一个数组类型 （固定大小内存块的别名）
typedef int(MyArr5)[5];
//定义一个指向数组类型的指针变量
MyArr5 *pArray;// &a;
{
int j = 0;
int *pI = &j;
}
{
//int buf[10][30]
//a1代表数组首元素的地址（不是整个数组的地址），请问a1 指针变量
//1变量-->2指针变量--》 3常量指针变量 (常量指针)
//结论：不能被随便的改变指针变量的值（不能随便的改变指针的指向）
//为什么它是一个const
//4在定义a1[5]的时候，编译器分配内存，为了能顺利的回收内存，为了有机会让编译器拿到原始内存首地址。
//编译器就把a1做成const量。
//不能深入的理解c指针各种现象，是产生bug的根源
int a1[5] = {1,3,4,55, 6};
//char *p = &a1;
//a1 = 0x11;
//给数组指针赋值 需要。。。&a1
MyArr5 *pArray = &a1; //4个字节
//用数组指针去遍历数组
for (i=0; i<5; i++)
{
//a1[i] = i;
// = i;
printf("%d ", (*pArray)[i]);
}
}
{
//直接定义一个 数组指针类型 用这个类型定义指针变量
//我声明了一个数组类型 （固定大小内存块的别名）
typedef int(MyArr5_1)[5];
//定义一个指向数组类型的指针变量
//声明一个 数组指针类型
typedef int (*PMyArr5)[5];
PMyArr5 myP = NULL;
int b[5] = {1,3,4,55, 6};
myP = &b;
for (i=0; i<5; i++)
{
//a1[i] = i;
// = i;
printf("%d ", (*myP)[i]);
}
}
{
int c[5] = {1,3,4,55, 6};
//定义一个指向数组的指针变量
int (*myparra)[5] = &c;
for (i=0; i<5; i++)
{
printf("%d ", (*myparra)[i]);
}
}
system("pause");
}#include "stdio.h"
#include "stdlib.h"
#include "string.h"
void main()
{
//a 是数组首元素的地址
int a[5]={3,4,5,6,2};
//1myarray 也是数组首元素的地址
//2myarray 是一个常量指针
//3 myarray 是一个数组指针
int myarray[3][5];//多为数组二维指针
//直接定义数组指针
int(*p)[5]=&a;
int i=0,j=0,temp=0;
for(i=0;i<5;i++)
{
printf("%d\n",(*p)[i]);
}
//&a 步长 5*4 =20 ;
for(i=0;i<3;i++)
{
for(j=0;j<5;j++)
{
myarray[i][j]=temp++;
}
}
printf("\n");
p=myarray;
for(i=0;i<3;i++)
{
for(j=0;j<5;j++)
{
printf("%d ",p[i][j]);
}
}
printf("myarray:%d myarray+1:%d",myarray,myarray+1);
printf("\n&a:%d &a+1:%d",&a,&a+1);
system("pause");
}#include "stdio.h"
#include "stdlib.h"
#include "string.h"
//1，不管是几纬数组，都是线性存储的。所以会存在多维数组做函数参数，退化问题
//2, 多维数组做函数参数，二维数组勉强表达出来，但是三围数组，四维数组，就表达不出来了
//结论：指针做函数参数，有效内存维数，只到2级。。如果你看到3级指针，4级指针，它表达的不是内存数组
int print2Array(int *a,int num)
{
int i=0;
for(i=0;i<num;i++)
{
printf("%d",a[i]);
}
}
void main()
{
//a 是数组首元素的地址
int a[5]={3,4,5,6,2};
//1myarray 也是数组首元素的地址
//2myarray 是一个常量指针
//3 myarray 是一个数组指针
int myarray[3][5];//多为数组二维指针
//直接定义数组指针
int(*p)[5]=&a;
int i=0,j=0,temp=0;
for(i=0;i<5;i++)
{
printf("%d\n",(*p)[i]);
}
//&a 步长 5*4 =20 ;
for(i=0;i<3;i++)
{
for(j=0;j<5;j++)
{
myarray[i][j]=temp++;
}
}
printf("\n");
p=myarray;
for(i=0;i<3;i++)
{
for(j=0;j<5;j++)
{
printf("%d ",p[i][j]);
}
}
printf("myarray:%d myarray+1:%d",myarray,myarray+1);
printf("\n&a:%d &a+1:%d",&a,&a+1);
system("pause");
}
多维数组本质
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
//spit(char a[][30])
//
void main33()
{
int i = 0, j = 0, tmp = 0;
//a是数组首元素的地址
int a [5] = {3, 4, 5, 6, 2};
//1 myarray数组首元素的地址吧
//2 myarray是一个常量指针 3k
//3 myarray是一个数组指针
int myarray[3][5];
//直接定义一个数组指针
int (*p)[5] = &a;
for (i=0; i<5; i++)
{
printf("%d\n", (*p)[i]);
}
//&a 步长 5*4 = 20;
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
myarray[i][j] = tmp++;
}
}
printf("myarray:%d myarray+1:%d", myarray, myarray+1);
printf("\n&a:%d &a+1:%d \n", &a, &a+1);
p = myarray;
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
p[i][j] = tmp++;
printf("%d ", p[i][j]);
}
}
system("pause");
}
//1 不管是几维数组，都是线性存储的。所以会存在多维数组做函数参数，退化问题
//2 多维数组做函数参数 二维数组，能勉强表达出来。但是三维数组，四维数组，，就表达不出来了。
//结论：指针做函数参数，有效内存维数，只到2级。。如果你看到3级指针 4级指针，它表示的不是内存的维数
int printf2Array(int *a, int num)
{
int i = 0;
for (i=0; i<num; i++)
{
printf("%d ", a[i]);
}
}
//int myarray(int a[][5])
void main35()
{
int myarray[3][5];
//int myarray[3][4][5];
int tmp = 0;
int *p = NULL;
int i=0, j = 0;
//直接定义一个数组指针
//&a 步长 5*4 = 20;
for (i=0; i<3; i++)
{
for (j=0; j<5; j++)
{
myarray[i][j] = tmp++;
//第i行第j列赋值
*(*(myarray+i)+j ) = tmp++;
}
}
p = (int *)myarray;
printf2Array(p, 3*5);
system("pause");
}
多维数组做函数参数技术推演
#include "stdio.h"
#include "stdlib.h"
#include "string.h"
//spit(char a[][30])
//
//指针类型不一样。=====》内存模型不一样吧。。。。
//没有内存那来的指针啊。。。。
int printfArr22(char **ArrayStr, int iNum)
{
int i = 0;
for (i=0; i<iNum; i++)
{
printf("%s \n", ArrayStr[i]);
}
return 0;
}
//int array[10]===>int *array===>
// int printfArr22(char array[10], int iNum);
//
int printf1Array(char buf[64]);
int printf1Array(char buf[]);
int printf1Array(char *buf);
//int printf2Array(char myArray[10][30])
int printfArr23_1(char myArray[10][30], int iNum)
{
int i = 0;
for (i=0; i<iNum; i++)
{
printf("%s \n", myArray[i]);
}
return 0;
}
int printf2Array_2(char myArray[][30], int iNum)
{
int i = 0;
for (i=0; i<iNum; i++)
{
printf("%s \n", myArray[i]);
}
return 0;
}
int printf2Array_3(char (*myArray)[30],int iNum)
{
int i = 0;
for (i=0; i<iNum; i++)
{
printf("%s \n", myArray[i]);
}
return 0;
}
// int printfArr22(char array[10], int iNum);
int sortArr23(char myArray[10][30], int iNum)
{
int i = 0, j = 0;
char buf[30]; //buf数组名代表数组首元素的地址
//排序
for (i=0; i<4; i++)
{
for (j=i+1; j<4; j++)
{
if (strcmp(myArray[i], myArray[j]) > 0)
{
strcpy(buf, myArray[i]);
strcpy(myArray[i],myArray[j]);
strcpy(myArray[j], buf);
}
}
}
}
void main44()
{
int i = 0;
char myArray[10][30] = {"ccccc", "aaaa", "bbbb","11111"}; //myArray数组名代表什么？抛砖
//打印第二种内存模型
for (i=0; i<4; i++)
{
printf("%s \n", myArray[i]);
}
printf("第二种内存模型，排序之前\n");
printf2Array_2(myArray, 4);
//printfArr23(myArray[10][30], 4);
sortArr23(myArray, 4);
printf("第二种内存模型，排序之后\n");
printf2Array_3(myArray, 4);
system("pause");
}
#include <stdio.h>
#include <stdlib.h>
void main()
{
int i=0;
//指针数组
char *p1[]={"123","456","789"};
//二维数组
char p2[3][4]={"123","456","789"};
//手工二维内存
char **p3=(char**)malloc(3*sizeof(char*));//int array[3];
for(i=0;i<3;i++)
{
p3[i]=(char*)malloc(10*sizeof(char));//char buf[10];
sprintf(p3[i],"%d%d%d",i);
}
//printf("%c",p2[0][2]);
}
#include "stdio.h"
#include "string.h"
#include "stdlib.h"
#include <stdio.h>
#include <string.h>
//演示：指针数组的用法
//演示：找错误 注意return
//求关键字在表中的位置
//一个入口 多个出口
int searcheKeyTable(const char* table[], const int size, const char* key, int *pos)
{
int rv = 0;
int i = 0;
int inum = 0;
if (table==NULL || key==NULL || pos==NULL)
{
rv = -1;
printf("func searcheKeyTable:%d", rv);
return rv;
}
inum = (sizeof(table)/sizeof(*table));
for(i=0; i<size; i++)
{
if( strcmp(key, table[i]) == 0 )
{
*pos = i;
//break;
return rv;
}
}
//没有找到返回-1
if (i == size)
{
*pos = -1;
}
return rv;
}
#define DIM(a) (sizeof(a)/sizeof(*a))
//DIM(c_keyword)===> (sizeof(c_keyword)/sizeof(*c_keyword))
int main()
{
int inum = 0;
int pos = 0;
int a[10];
int i = 0;
char* c_keyword[] = {
"while",
"case",
"static",
"do"
};
{
int a[10];
sizeof(a);
}
for(i=0; c_keyword[i]!=NULL; i++)
{
printf("%s\n", c_keyword[i]);
}
inum = (sizeof(c_keyword)/sizeof(*c_keyword));
searcheKeyTable( c_keyword, DIM(c_keyword),"do", &pos);
searcheKeyTable( c_keyword, inum,"do", &pos);
printf("pos:%d\n", pos);
//searcheKeyTable(NULL, DIM(c_keyword),"do", &pos);
//printf("pos:%d\n", pos);
searcheKeyTable( c_keyword, DIM(c_keyword), "static", &pos);
printf("pos:%d\n", pos);
getchar();
return ;
}
//main函数是操作系统调用的函数
//在程序执行的时候可以向main函数传递参数
/*
argc 命令行参数
argv 命令行参数数组
env 函数变量数组
int main();
int main(int argc);
int main(int argc, char *argv[])
*/
int main66(int argc, char* argv[], char* env[])
{
int i = 0;
//main02_1();
printf("******************* Begin argv *******************\n");
for(i=0; i<argc; i++)
{
printf("%s\n", argv[i]);
}
// for(i=0; argv[i]!=NULL; i++)
// {
// printf("%s\n", argv[i]);
// }
printf("******************* End argv *******************\n");
printf("\n");
printf("\n");
printf("\n");
printf("******************* Begin env *******************\n");
for(i=0; env[i]!=NULL; i++)
{
printf("%s\n", env[i]);
}
printf("******************* End env*******************\n");
getchar();
}
//
int main53()
{
int pos = 0;
int a[10];
int i = 0;
//指针数组当函数参数的时候，指针数组会退化为指针 需要把数组的个数传给被调用函数。。。。。。
char* c_keyword[] = {
"while",
"case",
"static",
"do", //常量字符串的首地址是不是一个32位的数
0 //填写一个零是不是应该
};
//[] * 区别是 【】只不过是编译器帮我们做了一个*p操作而已。
for (i=0; c_keyword[i]!=NULL;i++)
{
printf("%s \n", c_keyword[i]);
}
}
扫一扫
452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
