/**********************第二天的内容有点多，看官们耐心点看*********************/
指针与变量
1、指针的概念---->指针就是地址
2、指针的类型 是一种逻辑类型不是物理类型
"变量的类型 + *"
3、如何定义指针变量
"类型名 变量名"
变量尺寸占4个字节 4Byte
4、加减运算，解引用运算
加减都是加减绑定的字节数
NOTE:
对于指向变量的指针，加减运算没有意义
对于未知的内存，可读不可写 (不一定可读)
5、指向变量的指针在实际开发中的应用
扩展局部变量的作用域
通过参数返回值
函数的返回值类型通常为BOOL用于返回函数的执行状态
函数真正的返回值往往通过形参返回
6、几种特殊的指针
空指针 NULL或0 没有指向任何变量不可以解引用
通用指针 void*类型的指针就是通用指针
对通用指针的解释：
1 char c = 0; 2 int n = 0; 3 double d = 0; 4 5 void* p = &n; 6 p = &c; 7 p = &d;//可以转成许多类型可以指向任意类型 不能解引用 8 return 0; 9 //用处在于(double*)malloc(8)函数 10 // 强制转型因为原来是void*
7、字符串处理
7.1 存储的问题：字符数组用于存放字符
7.2 字符串的处理：拷贝 连接 大写转小写
截取指定位置后面的子串
删除字符串中指定的值
排序
倒置
数值串转整数串
整数串转数值串
2015/7/7号补充：常量字符串在内存中只有一个拷贝，因此指向同一个字符串的指针，他的地址
是相同的
8、一维数组与指针
定义：类型相同的变量的集合
初始化：
int arr[3] = {1,2,3};
int arr[3] = {1,2};//未赋值的元素全为0
int arr[] = {1,2,3};//长度会根据元素的个数确定
char str[3] = {'a','a','a'};//不是字符串
char str[3] = {'a','a'};//是字符串
char str[] = {'a','a'};//不是字符串
char str[] = "china";//常用字符串直接赋值
存储：不论是几维数组，变量的内存都是连续的
遍历：从头到尾的对所有变量进行读或写
一维数组的地址关系：
一维数组的数组名是首元素的地址
是一个地址常量
对一维数组与指针的理解：
1 #include <stdio.h> 2 #define ARR_SIZE 3 3 int main() 4 { 5 6 int arr1[] = {1,2,3}; 7 int arr2[] = {1,2}; 8 int arr3[] = {1,2,3}; 9 10 char str1[3] = {'a','b','c'}; 11 char str2[3] = {'a','b'}; 12 char str3[] = {'a','b','c'}; 13 char str4[] = "china"; 14 15 int i=0; 16 // 17 for(i=0; i<sizeof(arr1)/sizeof(int);i++) 18 { 19 printf("%d ",sizeof(str4)); 20 } 21 22 23 int a[ARR_SIZE] = {0}; 24 int* p = &a[0]; 25 printf("%d,%d,%d\n",&a[0],p,a); 26 printf("%d,%d,%d\n",&a[1],p+1,a+1); 27 printf("%d,%d,%d\n",&a[2],p+2,a+2); 28 } 29 //当 sizeof 运算符应用于类型 char时对象，它提供 1。 当 sizeof 运算符应用于数组时， 它提供总字节数。 30 //需要改变指向的时候用指针 不需要改变指向的时候用引用
传参：三种写法
//貌似只记录了两种
1 #include <stdio.h> 2 #define ARR_SIZE 3 3 4 //void display(int *p,int len) 5 void display(int p[],int len) 6 { 7 int i=0; 8 for(i=0; i<len;i++) 9 { 10 printf("%d",p[i]); 11 } 12 13 for(i=0; i<len;i++) 14 { 15 printf("%d",*(p+i)); 16 } 17 18 for(i=0; i<len;i++) 19 { 20 printf("%d",*p++);//相当于*(p++) 21 //但不同于(*p)++，这样也会输出123，因为此时(*p)是内存的标识，相当于一个变量 22 } 23 } 24 int main() 25 { 26 int arr[ARR_SIZE] = {1，2，3}; 27 display(arr,ARR_SIZE); 28 }
对(*)以及(&)的理解：
1 ************************************** 2 int a[4]; 3 &a[0] &a[1] &a[2] &a[3] 4个常量 4 int* p = &a[0]; 5 p p+1 p+2 p+3 4 6 a a+1 a+2 a+3 4 7 加*缩加&扩 *&相互抵消 8 a[0] a[1] a[2] a[3] 4个变量 9 *p *(p+1) *(p+2) *(p+3) 4 10 *a *(a+1) *(a+2) *(a+3) 4 11 **************************************
**************************************
二维数组与指针
定义：就是一维数组的集合
初始化
int a[2][3] = {{1,2,3},{1,2,3}};//按行全部
int a[2][3] = {{1},{1,2}};//按行部分，未赋值的元素全0
int a[][3] = {{1,2},{1,2},{1}};//按行省略行下标
int a[2][3] = {{1,2,3},{}}//error
NOTE:按行赋初值的时候行括号的个数必须和行下标相同，且行括号内部必须有值
存储：变量的内存是连续的
遍历：用双重循环遍历
变量之间的地址关系：二维数组是由一维数组构成的
所以二维数组名表示第一个一维数组的地址
int a[2][3]
*(*(a+1)+2)---->*(a[1]+2)---->a[1][2]
**************************************
数组的地址就是"数组指针"！
int (*p)[3]//指向长度为3的整形一维数组的指针
char (*p)[100];//指向长度为100的char型的一维数组的指针
char (*p)[120] = NULL;
char a[2][100];
p = a;//error 绑定长度不同 120 != 100
二维数组做函数参数：
1 #define ROW 2 2 #define COLUMN 10 3 //char p[][COLUMN] 4 void display(char(*p)[COLUMN],int row) 5 { 6 int i=0; 7 int j=0; 8 for(i=0; i<row; i++) 9 { 10 puts(p[i]);//首元素的地址给出 p代表一行的首元素地址 11 } 12 } 13 14 int main() 15 { 16 char a[ROW][COLUMN] = {"china","japan"}; 17 18 display(a,ROW); 19 20 return 0; 21 }
多维数组与指针
char a[3][4][5];
三维数组是二维数组构成的，所以数组名a表示第一个二维数组的地址，绑定了20个变量
*(*(*(a+1) + 2) + 3)---->a[1][2][3]
char (*p)[4][5] = a;
void display(int (*p)[3][4])
{
}
int main()
{
int a[3][4][5] = {0};
display(a);
}
const与指针
const int var = 0;//常量
100//字面值 存储在常量区
const int* p = &val;//const限定了*p 只能读不能写
int* const p = &val;//const 修饰了p 不能修改指向 必须初始化
内存的访问权限只能缩小不能扩大
const int k = 100;
int* p = &k;//wrong
int k = 0;
const int* p = &k;//Ok
int a = 0;
int& r = a;//引用必须初始化
r = 100;//a的小名 引用占四个字节
数组与指针绑定元素个数：
1 #include <stdio.h> 2 #include <string.h> 3 4 int main() 5 { 6 char src[100] = "china"; 7 printf("%d %d %d",src,&src[0],&src);//src 首元素的地址 绑定的字节数为1 8 //&src[0] 绑定的字节数为1 9 //&src 绑定的字节数为100 10 //扩容 但是存储的还是首元素的地址 11 }
C语言部分库函数实现：
1 #include <stdio.h> 2 #include <malloc.h> 3 #include <windows.h> 4 5 char* Strcpy(char* _dest,const char* _source) 6 { 7 char* tmp = _dest; 8 while(*_source) 9 { 10 *_dest++ = *_source++; 11 } 12 *_dest = '\0';//容易忘 13 return tmp; 14 } 15 16 char* Strcat(char* _dest,const char* _source) 17 { 18 char* tmp = _dest; 19 while(*_dest) 20 { 21 _dest++; 22 } 23 24 while(*_source) 25 { 26 *_dest++ = *_source++; 27 } 28 *_dest = '\0'; 29 30 return tmp; 31 } 32 33 char* StrUpr(char* pStr) 34 { 35 char* tmp = pStr; 36 while(*pStr) 37 { 38 if(*pStr >= 'a' && *pStr <= 'z') 39 { 40 *pStr -= 32; 41 } 42 *pStr++; 43 } 44 return tmp; 45 } 46 47 char* StrLwr(char* pStr) 48 { 49 char* tmp = pStr; 50 while(*pStr) 51 { 52 if(*pStr >= 'A' && *pStr <= 'Z') 53 { 54 *pStr += 32; 55 } 56 *pStr++; 57 } 58 return tmp; 59 } 60 61 int StrCmp(const char* _dest,const char* _src) 62 { 63 while(*_dest) 64 { 65 if(*_dest != *_src) 66 { 67 return *_dest - *_src; 68 } 69 _dest++; 70 _src++; 71 } 72 return *_dest - *_src; 73 } 74 75 void DelChar(char* str,char ch) 76 { 77 /*char* p = (char*)malloc(strlen(str)); 78 while(*str) 79 { 80 if(*str != ch) 81 { 82 *p++ = *str; 83 } 84 str++; 85 } 还有问题 86 *p = '\0'; 87 Strcpy(str,p); 88 free(p);*/ 89 char *p = str; 90 while(*str) 91 { 92 if(*str != ch) 93 { 94 *p++ = *str; 95 } 96 str++; 97 } 98 *p = '\0'; 99 } 100 101 void Sort(char (*p)[100],int nCount)//定义一个绑定一维数组的指针 102 { 103 int i=0; 104 int j=0; 105 char tmp[100] = ""; 106 for (i = 0; i < nCount-1; i++)//轮数 107 { 108 for (j = 0; j < nCount-i-1; j++)//每一次比较的次数 109 { 110 if(StrCmp(p[j],p[j+1])<0)//large----small 111 { 112 Strcpy(tmp,p[j]); 113 Strcpy(p[j],p[j+1]); 114 Strcpy(p[j+1],tmp); 115 } 116 } 117 } 118 } 119 120 121 #include <string.h> 122 int main() 123 { 124 /*char src[100] = "nnnchnnninannn"; 125 char dest[100] = "ci";*/ 126 /*Strcpy(dest,src); 127 Strcat(dest,src); 128 129 StrUpr(dest); 130 puts(dest); 131 StrLwr(dest); 132 puts(dest); 133 strcmp(dest,src);*/ 134 /*DelChar(src,'n'); 135 puts(src);*/ 136 char str[100]; 137 char* p = str; 138 char arr[3][100] = {"China","Japan","Usa"}; 139 Sort(arr,3); 140 puts(*arr); 141 puts(*(arr+1)); 142 puts(*(arr+2)); 143 return 0; 144 }
