2017/12/7C语言笔记整理

#####指针：保存地址的，地址是一个数字。

//左值代表空间，优质代表空间里的内容。

//1.定义一个指针变量p，类型是int*.

 2.p指向一个int型的数据。

//指针的绑定

 int *p，a；p=&a；

 int *p1=&a；//定义指针的同时，并且初始化。

//指针的解引用；*p得到了变量（a）。

 *p=23；

//指针的运算

 p1++；//指针所指向的变量类型所占字节大小（sizeof（int））*1

//const关键字，修饰的变量是常数，不可更改。只能初始化一次。

1.const int b;

 b=23; //error:assignment of read-only variable'a'.

 int *p=&b;

 *p=11;

 printf("b=%d",*p);//waring:assinment discards 'const'qualifier from pointer target type[enabled by default]

2.const int a=23; //1.先拿到a的首地址

 int *p=（int*）&a  //强制类型转换

 printf("a=%d.\n",*p=11); //修改a的值

 a=33；       //报错

 printf（"a=%d.\n",a）;

/* printf（"p=%p.\n",p）;

   printf（"&p=%p.\n",&p）;

   值不一样

*/

//const修饰只读变量

 inta=0x12345678;

 char *p=(char*)&a;

 int i=0;

 for(i=0;i<4;i++)

 {

   printf("%x\n",*(p+i));

 }

打印结果：78 56 34 12

// const int a=10;

  intarr[a]={};//error:variable-sized object may not be initialized.

  原因：1.const修饰只读变量。2.在C++里面对const进行了扩展，标识常量。

//宏定义和const?

 const：在修饰函数参数时，表示输入型参数。

//const与指针，就近原则。

 1.int const*p1;

   p1=&a;

   *p1=11;error:assignment of read-only location '*p1'

 2.const int*p2;//p2可改变；p2所指向的数据（int）指向内容不可改变。

   p2=&a;     

   *p2=11;error:assignment of read-only location '*p2'

 3.int * constp3;//修饰p3，也就是说p3指向内容可以改变。

   p3=&a;error:assignmentof read-only location 'p3'

   *p3=11;

 4.const int *const p4; //必须定义时同时初始化。

   p4=&a;error:assignment of read-only location 'p4'

   *p4=11;error:assignment of read-only location '*p4'

//野指针

 int *p；//p==NULL

 野指针危害：1.直接指向内核区，2.指向可用也没有别的数据的区域。3.最可怕，可用但有别的数据。

//NULL专用于指针的初始化（写'0'）NULL编译器内置宏

 int *p=NULL；（（void*）0）；

#include <stdio.h>

int main(void)

{

/* intarr[5]={1,2,3,4,5};

   //arr作右值

   int*p=arr;==int *p=&arr[0];

   //*p++==*(p++)

   printf("*p++=%d.\n",*p++);//*p==arr[0]=1;p++//输出1

   printf("*(p++)=%d.\n",*(p++));//先赋值后进行p++//输出2

*/

   intarr[5]={1,3,5,7,9};

   printf("*++p=%d.\n",*++p);//(++p)->*()//输出3

   『printf("(*p)++=%d.\n",(*p)++);//先赋值，arr[1]=arr[1]+1//*p=(*p)+1输出3

   printf("*p=%d,(*p)++=%d.\n",*p,(*p)++);//输出4，3』

   printf("*p=%d.\n",*p);//输出4

}

//同一数组，指针相减是一个数。

 intarr[5]={1,3,5,7,9};

 int *p=arr;

 int *q=arr+5;

 int ret=q-p;

 printf("ret=%d.\n",ret);

 return 0;

//

#include <stdio.h>

void func1(int a)

{

   //相当于局部变量，函数调用结束就销毁。

   printf("&a=%p.\n",&a);

   a=13;

   //不要返回局部变量地址

   return&a;

}

int main(void)

{

   int val=0;

   printf("&val=%p.\n",&val);

   funcl(val);

   printf("val=%d.\n",val);

}

//函数的输出型参数

void func2(int *p)

{

   printf("p=%p.\n",p);

   *p=23;

}

int main(void)

{

   int a=11;

   printf("&a=%p.\n",&a);

   func2(&a);//传址调用

   printf("a=%d.\n",a);

}

//用指针使两个数进行交换。

#include <stdio.h>

void swap(int *p1,int *p2)

{

   int a=0;

   a=*p1;

   *p1=*p2;

   *p2=a;

}

//1.数组名作为函数参数退化为一个指针。

 2.子函数内部改变了原数组里面的内容。

void func_arr(int *arr,int lenth)

{

   printf("arr=%p.\n",arr);

   printf("sizeof(arr)=%d.\n",sizeof(arr));

}

int main(void)

{

   intarr[3]={1,2,3};

   func_arr(arr,3);

   printf("arr=%p.\n",arr);

   return 0;

}

void func_arr(int *arr,int lenth)

{

   *arr=11;//==arr[0]=11;

   arr[1]=22;

}

int main(void)

{

   intarr[3]={2,5,8};

   func_3arr(arr,3);

   printf("arr[1]=%d.\n",arr[1]);

   return 0;

} 

//1.C++:new delete相互配合使用，申请的是堆空间（也是一段内存）。

 2.new：类名

eg：new int:创建一个int类型的数；

   new int(0):创建一个初始化数据；

   newstring[10]:创建10个字符串类型的数组；

   new int[10]:创建10个整型的数组。

 3.new是一个运算符和sizeof一样。

//堆内存也是内存的一种，需要程序员自己手动申请，手动释放，编译器不会自动回收。伴随整个函数。

malloc:

//用指针对数组进行排序

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//对元素进行存储

void set_value(int *p,int lenth)

{

   int i=0;

   printf("请输入你要排序的数组元素：\n");

   for(i=0;i<lenth;i++)

   {

       scanf("%d",p++);

   }

}

void arr_show(int *p,int lenth)

{

   int i=0;

   for(i=0;i<lenth;i++)

   {

       printf("%d",*p++);

   }

   printf("\n");

}

void swap(int *p1,int *p2)

{

   int temp=0;

   temp=*p1;

   *p1=*p2;

   *p2=temp;

}

//冒泡排序

void fun_arr(int *p,int lenth)

{

   int i=0,j=0;

   for(i=0;i<lenth-1;i++)

   {  

       for(j=0;j<lenth-1-i;j++)

       {

           if(*(p+j)>*(p+j+1))

           {

               swap(p+j,p+j+1);

           }  

       }

   }

}

//选择排序

void xuanze(int *p,int lenth)

{

   int i=0,j=0;

   for(i=0;i<lenth-1;i++)

   {

       for(j=i+1;j<lenth;j++)

       {

           if(*(p+i)>*(p+j))

           {

               swap(p+i,p+j);

           }

       }

   }

}

//申请空间

int* shenqing(int num)

{

   int *p=(int*)malloc(num*sizeof(int));

   if(NULL==p)

   {

       return p;

   }

   //清空这段内存

   memset(p,0,num*sizeof(int));

   return p;

}

int main(void)

{

   int num=0;

   printf("请输入你要排序的数组大小:\n");

   scanf("%d",&num);

   int*p=shenqing(num);

   set_value(p,num);

   arr_show(p,num);

// fun_arr(p,num);

   xuanze(p,num);

   arr_show(p,num);

   if(NULL!=p)

   {

       free(p);

       p=NULL;

   }

   return 0;

   

}

int main(void)

{

   //malloc申请空间，默认是有最小分配的。

   char *p=(char*)malloc(0);

   if(p==NULL

   printf(“error.\n”); //结果不会输出

   return 0;

}

#define DPchar char *与#typedef char * tpchar区别

//typedef是重命名的关键字，他不是发明新类型，而是给类型起了个新外号。

举例：

Int main(void)

{

   DPchar p1,p2;  //p1是指针，p2是char变量

   Tpchar p3,p4;  //定义了两个指针

}

//函数是一个地址，也就可以理解成指针，所以函数也可以用类型这个理解方法。

//类型名+变量名

//定义一个函数指针，并且绑定，C语言里对函数名的绑定有两种方式。

Eg:void (*p) (void)=func;

  Void (*p)(void)=&func;

//调用函数，指针的节引用。

P();   ==(*p)();  

typedef void (*p_func) (void);//void (void)表示一个类型，p_func是一个类型的名字，函数指针。

int main(void)

{

   P_func p;//定义该类型的一个指针数组。

   P=func;//绑定。

   P();//调用函数。

}

//函数指针数组：数组里面的元素都是指针（函数指针）。

typedef void (*p_arr[10]) (void)

{

   P_arrarr={func,func};

}

Int main(void)

{

   //指针数组是一个数组，里面的元素是指针。

   int*p_arr[5];

   intarr[5]={1,2,3,4,5};

// p_arr[0]=arr;

// p_arr[1]=arr+1;

   int i=0;

   for(i=0;i<5;i++)

   {

       P_arr[i]=arr+I;

　　}

}

int main(void)

{

   //二维数组，变量名，首元素首地址

   int arr[2][3]={1,2,3,4,5,6};

   //数组指针，指针指向一个int[3]类型的数据结构；

   int (*p) [3];

   p=arr;

   //遍历二维数组

   int i=0;j=0;

   for(i=0;i<2;i++)

   {

       for(j=0;j<3;j++)

       {

           printf(“*(*(p+%d)+%d)=%d”,i,j,*(*(p+i)+j));

　　}

　　}

　　//arr代表数组首元素首地址

　　//&arr[0]代表一维数组首元素的首地址

　　//&arr[0][0]代表数组第二维是首元素首地址

}