记中兴软件园一个月实训(二)

/**********************第二天的内容有点多，看官们耐心点看*********************/

指针与变量
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
",&a[0],p,a);
26 printf("%d,%d,%d
",&a[1],p+1,a+1);
27 printf("%d,%d,%d
",&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 = '';//容易忘
 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 = '';
 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 = '';
 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 = '';
 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 }