有基础C语言复习巩固（易忘点、易错点）（二、函数、指针、结构体）

     函数     

int judge(int x){

        if(x>0) return 1;

        else if(x==0) return 0;

        else return -1;

}

int main(){

        int a,ans;

        scanf("%d",&a);

        ans = judge(a);

        printf("%d",ans);

        return 0;

}

---

       全局变量与局部变量       

全局变量

#include<stdio.h>

int x;         //定义一个全局变量

void change(){

        x=x+1;

        }

int main(){

        x=10;

        change():

        printf("%d",x);

        return 0;

}

输出结果：11

局部变量

#include<stdio.h>

void change(int x){        //x为形参  尽在函数内部生效

        x = x+1;

}

int main(){

        int x=10;

        change(x);       //x为实参

        printf("%d",x);    //x为10不变

        return 0;

}

 输出结果：10

以数组作为函数参数      (以数组作为参数，一维不需要填写长度，如果是二维数组，第二位需要填写长度，实际调用时只需要写数组名）

数组作为参数时，在函数中对于数组元素的修改就等同于是对原数组元素的修改（这与普通的局部变量不同）

#include<stdio.h>

 void change(int a[],int b[][5]){

        a[0] = 1;

        a[1] = 3;

        a[2] = 5;

        b[0][0] = 1;

}

int main(){

        int a[3] = {0};

        int b[5][5] = {0};

        change(a,b);

        for(int i = 0;i<3;i++){

                printf("%d",a[i]);

}

        return 0;

}

输出结果：135

---

     指针      

int* p；   //定义指针     int为指针储存的地址的数据类型

int  *p1，*p2，*p3；

int * p=&a;  //给指针赋值

int *p； p=&a；  //与上面相同

注：指针就是所指元素的地址   *就像该房间钥匙    所以*p就是把房间打开，得到房间里的东西

#include<stdio.h>

int main(){

        int a;

        int *p = &a;

        a = 233;        //等同于*p=233

        printf("%d\n",*p);      //接上面  printf("%d\n",a); 结果相同

        return 0;

}

输出结果：233

---

     指针与数组     

数组名称也作为数组的首地址使用，所以有a = &a[0]

---

   使用指针变量作为函数参数    

注：当使用指针变量作为函数参数，在函数中对这个元素的地址进行改编，原先的数据就确实会改变

使用指针作为参数交换两个数

#include <stdio.h>

void swap(int *a,int *b){

        int temp = *a;    //也可写为int i;  int *temp = *a

        *a = *b;

        *b = temp;

}

void main(){

        int a = 1,b = 2;

        int *p1 = &a,*p2 = &b;

        swap(p1,p2);

        printf("%d\n%d",a,b);     //a，b等同于*p1，*p2

        return 0;

}

输出结果：2

                  1

---

     引用      

引用不产生副本而是给原变量起了个别名，而且对引用变量的操作就是对原变量的操作

include <stdio.h>

void change(int &x){

        x = 1；

}

int main(){

        int a = 10;

        change(a);

        printf("%d",a);

        return 0;

}

输出结果:1

上面的交换还可以写成

void swap(int* &p1,int* &p2）{

        int* temp = p1;

        p1 = p2;

        p2 = temp

}

void main(){

        int a = 1,b = 2;

        int *p1 = &a,*p2 = &b;

        swap(p1,p2);

        printf("%d\n%d",a,b);     //a，b等同于*p1，*p2

        return 0;

}

---

      结构体     

定义：如

struct studentInfo{

        int id;

        char gender;//"F"or"M"

        char name[20];

        char major[20];

        studentInfo  *next;

}Alice,Bob,stud[1000] ，*p；//直接定义了两个结构体变量、一个结构体数组、指针p

studentInfo Alice,Bob;

studentInfo stud[1000];

 定义结构体指针：

struct node{

        错的node n;          //结构体不能定义自己类型的变量

        node *next;        //但可以定义自己类型的指针

}

 访问结构体内元素

struct studentInfo{

        int id;

        char name[20];

        studentInfo *next；

}stu,*p；

访问stu中变量

stu.name;

stu.id;

stu.next;

访问指针p中元素

p->id;

p->name;

p->next;

 除了一个一个的赋值，我们还可以用构造函数来对结构体进行初始化

每个结构体会有一个默认的构造函数，当自己重新定义构造函数时就会对默认的进行覆盖，所以最好手动加上，否则不能不经初始化就定义结构体变量

struct studentInfo{

        int id;

        char gender;

        //用以不初始化就定义结构变量

        studentInfo(){}

        //只初始化gender

        studentInfo(char  _gender){

                gender = _gender;

}

        //同时初始化id和gender

                studentInfo(char_id,char  _gender){

                id = _id;  

                gender = _gender;

}

//需要时就可以直接对结构体变量进行赋值了

studentInfo stu = studentInfo(10086,'M');

studentInfo stu = studentInfo('M');

应用实例：

 #include<stdio.h>

struct Point{

        int x,y;

        Point(){}

        Point（int_x,int_y）: x(_x),y(_y) {}

}pt[10];

int main(){

        int num = 0;

        for(int i = 1;i<=3;i++){

                for(int j=1;j<=3;j++){

                        pt[num++] = Point(i,j);

}

}

       for(int i=0;i<num;i++){

                printf("%d,%d\n",pt[i].x,pt[i].y) ;       

}

        return 0;

}

     浮点数度比较     

由于计算机中采用有限的二进制编码，因此浮点数在计算机中的存储并不总是精确的。例如在经过大量计算后，一个浮点型的3.14在计算机中就有可能储存成3.140000000001，也有可能储存成3.149999999999，这种情况下会对操作带来极大的困扰（因为C/C++中的“==”操作时完全相同才能判定为true）于是需要引入一个极小数eps来对这种误差进行修正。

#define Equ(a,b)  (fabs(a)-(b))<(eps))

#define More(a,b)  ((a)-(b))>(eps))

#define Less(a,b)  ((a)-(b))<(-eps))

#define MoreEqu(a,b)  ((a)-(b))>(-eps))

#define LessEqu(a,b)  ((a)-(b))<(eps))

   圆周率pai可以写成   

const double Pi = acos（-1）；