c语言基础——关键字static,const,extern 堆栈，动态分配malloc，类型重定义typedef，宏定义define

 1.关键字

①案例 const 

int a = 10;
const int b = 20; // ==  int const b = 20; 常变量
int *pa = &a; //合法
//int *pb = &b; //不合法
//*pb = 78;
int const *ppb = &b; //合法

如果想保存常变量的地址，需要对指针加以限制。
【指针常量】int const *p; //表示该指针的指向可以改变，指针指向里的值不可被改变
【常量指针】int * const p;//表示该指针的指向不可变，指向里的值可变。
int const * const p; //都不可变

②案例 static

#include<stdio.h>
//静态局部变量
void fun()
{
        static int count = 0; //静态局部变量  申请空间 不释放
        count++;
        printf("count: %d\n",count);

}

#include<stdio.h>
static int x = 42; //静态全局变量

 ③案例 extern

引用外部变量
// file1.c
#include<stdio.h>
int x = 42; //全局变量


// file2.c
#include<stdio.h>
extern int x; //声明外部变量

int main(int argc, const char *argv[])
{
    printf("x = %d\n",x);
    
    return 0;
}

引用外部函数
//file1.c
#include<stdio.h>
void fun()
{
        printf("hello meimei\n");
}


//file2.c
#include<stdio.h>
extern void fun(); //声明引用外部函数  fun
int main(int argc, const char *argv[])
{
        fun();    
        return 0;
}

 // gcc file2.c file1.c

2. 内存空间划分

 

 3.动态内存分配和回收

 ①案例malloc free

#include<stdio.h>
#include<stdlib.h>

int main(int argc, const char *argv[])
{
        //在堆区申请了4个字节的大小空间，并将地址赋值给p1
        int *p1 = (int *)malloc(sizeof(int));
        printf("*p1 = %d\n",*p1);//随机值
    
        *p1 = 100;
        printf("*p1 = %d\n",*p1);
    
        //在堆区连续申请了5个4个字节的大小空间，并将地址赋值给p2
        int *p2 = (int *)malloc(sizeof(int)*5);
        for(int i=0; i<5; i++)
        {
            //printf("%d ",p2[i]);
            // ==> printf("%d ", *(p2+i));
    
            p2[i] = i+1;
    
        }
        for(int i=0; i<5; i++)
        {
            printf("%d ",p2[i]);
        
        }
        printf("\n");
    
        //释放堆区空间
        free(p1);
        free(p2);
    
        //避免野指针，要给指针来个指向
        p1 = NULL;
        p2 = NULL;
    
    
    
    
        
        return 0;
}

 ②案例【野指针】

//野指针
1.定义指针，未初始化，就直接使用，是野指针。
    eg:
        int *ptr;
        *ptr = 10;
2. 指针指向堆区空间，释放该空间后，没有给指针置空或者重新指向，该指针是野指针。

3. 定义指针指向数组，通过指针遍历数组中的元素，越界访问，该指针是野指针。
    eg:
        int arr[5];
        int *ptr = arr;
        printf("%d \n",*(ptr+5));
4. 指针指向一个函数返回值，【函数调用时，分配空间，函数结束后，释放空间】，该指针是野指针
    eg:
        int *fun()
        {
            int num = 100;
            return #        
        }
        int *p = fun();

 4.传值，传地址，值返回，地址返回

 

 5.typedef 类型重定义

6. define宏定义

#define 宏名 字符串

eg:
    #define N 10
    #define N =10  //不做正确性的检查

 ①案例  带参宏定义

 #include<stdio.h>
    //定义一个带参宏
    #define MAX(x,y) x>y?x:y
    
    int max(int x, int y)
    {
        return x>y?x:y;
    
    }
    int main(int argc, const char *argv[])
    {
        int m=1,n=1;
        int c = max(++m,n);
        printf("m = %d, n = %d, c = %d\n",m,n,c);
    
        m=1;
        n=1;
        c = MAX(++m,n);
        printf("m = %d, n = %d, c = %d\n",m,n,c);
        return 0;
    }

 

作业：

在堆区空间连续申请5个int类型大小空间，用来存放从终端输入的5个学生成绩，然后显示5个学生成绩，再将学生成绩升序排序，排序后，再次显示学生成绩。显示和排序分别用函数完成

要求：用malloc和free完成  

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void display(int *score,int size)
{
	for(int i=0;i<size;i++)
	{
		printf("%d ",score[i]);
	}
	putchar(10);
}
void sort(int *score,int size)
{
	for(int i=0;i<size-1;i++)
	{
		for (int j=0;j<size-1-i;j++)
		{
			if (score[j]>score[j+1])
			{
				int temp=score[j];
				score[j]=score[j+1];
				score[j+1]=temp;
			}
		}
	}
}
int main(int argc, const char *argv[])	
{
	int *score;
	int i;

	score=(int*)malloc(sizeof(int)*5);
	if(score==NULL)
	{
		printf("内存分配失败");
		return 1;//返回非零值表示错误
	}

	printf("enter 5 scores:\n");
	for (i=0;i<5;i++)
	{
		printf("score %d:",i+1);
		scanf("%d",&score[i]);
	}
	//显示成绩
	printf("输入的成绩为：\n");
	display(score,5);

	//排序成绩
	sort(score,5);

	//显示成绩again
	printf("排序后成绩为：\n");
	display(score,5);

	//释放内存
	free(score);

	return 0;
}