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

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

指针与变量
1、指针的概念---->指针就是地址
2、指针的类型 是一种逻辑类型不是物理类型
"变量的类型 + *"
3、如何定义指针变量
"类型名 变量名"
变量尺寸占4个字节 4Byte
4、加减运算，解引用运算
加减都是加减绑定的字节数
NOTE:
对于指向变量的指针，加减运算没有意义
对于未知的内存，可读不可写
5、指向变量的指针在实际开发中的应用
扩展局部变量的作用域
通过参数返回值
函数的返回值类型通常为BOOL用于返回函数的执行状态
函数真正的返回值往往通过形参返回
6、几种特殊的指针
空指针 NULL或0 没有指向任何变量不可以解引用
通用指针 void*类型的指针就是通用指针

对通用指针的解释：

char c = 0;
int n = 0;
double d = 0;

void* p = &n;
p = &c;
p = &d;//可以转成许多类型可以指向任意类型 不能解引用
return 0;
//用处在于(double*)malloc(8)函数
// 强制转型因为原来是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 //需要改变指向的时候用指针 不需要改变指向的时候用引用

传参：三种写法

//貌似只记录了两种

#include <stdio.h>
#define ARR_SIZE 3

//void display(int *p,int len)
void display(int p[],int len)
{
int i=0;
for(i=0; i<len;i++)
{
printf("%d",p[i]);
}

for(i=0; i<len;i++)
{
printf("%d",*(p+i));
}

for(i=0; i<len;i++)
{
printf("%d",*p++);//相当于*(p++)
//但不同于(*p)++，这样也会输出123，因为此时(*p)是内存的标识，相当于一个变量
}
}
int main()
{
int arr[ARR_SIZE] = {1，2，3};
display(arr,ARR_SIZE);
}

对(*)以及(&)的理解：

**************************************
int a[4];
&a[0] &a[1] &a[2] &a[3] 4个常量
int* p = &a[0];
p      p+1    p+2   p+3  4
a      a+1    a+2   a+3  4
加*缩加&扩      *&相互抵消
a[0] a[1] a[2] a[3]     4个变量
*p *(p+1) *(p+2) *(p+3) 4
*a *(a+1) *(a+2) *(a+3) 4
**************************************

**************************************
二维数组与指针
定义：就是一维数组的集合
初始化
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

二维数组做函数参数：

#define ROW 2
#define COLUMN 10
//char p[][COLUMN]
void display(char(*p)[COLUMN],int row)
{
int i=0;
int j=0;
for(i=0; i<row; i++)
{
puts(p[i]);//首元素的地址给出 p代表一行的首元素地址
}
}

int main()
{
char a[ROW][COLUMN] = {"china","japan"};

display(a,ROW);

return 0;
}

多维数组与指针
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的小名 引用占四个字节

数组与指针绑定元素个数：

#include <stdio.h>
#include <string.h>

int main()
{
char src[100] = "china";
printf("%d %d %d",src,&src[0],&src);//src 首元素的地址 绑定的字节数为1
//&src[0] 绑定的字节数为1
//&src  绑定的字节数为100
//扩容 但是存储的还是首元素的地址
}

C语言部分库函数实现：

#include <stdio.h>
#include <malloc.h>
#include <windows.h>

char* Strcpy(char* _dest,const char* _source)
{
char* tmp = _dest;
while(*_source)
{
*_dest++ = *_source++;
}
*_dest = '\0';//容易忘
return tmp;
}

char* Strcat(char* _dest,const char* _source)
{
char* tmp = _dest;
while(*_dest)
{
_dest++;
}

while(*_source)
{
*_dest++ = *_source++;
}
*_dest = '\0';

return tmp;
}

char* StrUpr(char* pStr)
{
char* tmp = pStr;
while(*pStr)
{
if(*pStr >= 'a' && *pStr <= 'z')
{
*pStr -= 32;
}
*pStr++;
}
return tmp;
}

char* StrLwr(char* pStr)
{
char* tmp = pStr;
while(*pStr)
{
if(*pStr >= 'A' && *pStr <= 'Z')
{
*pStr += 32;
}
*pStr++;
}
return tmp;
}

int StrCmp(const char* _dest,const char* _src)
{
while(*_dest)
{
if(*_dest != *_src)
{
return *_dest - *_src;
}
_dest++;
_src++;
}
return *_dest - *_src;
}

void DelChar(char* str,char ch)
{
/*char* p = (char*)malloc(strlen(str));
while(*str)
{
if(*str != ch)
{
*p++ = *str;
}
str++;
}                还有问题
*p = '\0';
Strcpy(str,p);
free(p);*/
char *p = str;
while(*str)
{
if(*str != ch)
{
*p++ = *str;
}
str++;
}
*p = '\0';
}

void Sort(char (*p)[100],int nCount)//定义一个绑定一维数组的指针
{
int i=0;
int j=0;
char tmp[100] = "";
for (i = 0; i < nCount-1; i++)//轮数
{
for (j = 0; j < nCount-i-1; j++)//每一次比较的次数
{
if(StrCmp(p[j],p[j+1])<0)//large----small
{
Strcpy(tmp,p[j]);
Strcpy(p[j],p[j+1]);
Strcpy(p[j+1],tmp);
}
}
}
}

#include <string.h>
int main()
{
/*char src[100] = "nnnchnnninannn";
char dest[100] = "ci";*/
/*Strcpy(dest,src);
Strcat(dest,src);

StrUpr(dest);
puts(dest);
StrLwr(dest);
puts(dest);
strcmp(dest,src);*/
/*DelChar(src,'n');
puts(src);*/
char str[100];
char* p = str;
char arr[3][100] = {"China","Japan","Usa"};
Sort(arr,3);
puts(*arr);
puts(*(arr+1));
puts(*(arr+2));
return 0;
}