C语言基础四之内存四区

静态

static 增强了局部变量的声明周期；限制了全局变量的作用域

静态局部变量

void test(){
    //静态变量只初始化一次
    static int c  = 10;
    int d = 10;
    c++;
    d++;
    
    printf("c = %d \n",c);
    printf("d = %d \n",d);
}

int main(int argc, const char * argv[]) {
    test();
    test();
    return 0;
}

案例二
    
    
int main(int argc, const char * argv[]) {
    
    int a = 1000;
    //此处的中括号相当于匿名函数
    {
        printf("%d \n",a);
        int a = 10;
         printf("%d \n",a);
    }
    printf("%d \n",a);
    return 0;
}

静态全局变量

//file hello.c
//全局变量的作用域为整个项目
int a = 10;
//静态全局变量的作用域为当前文件
static int b = 100;

//file main.c
extern int a;
extern int b;

int main(int argc, const char * argv[]) {
   
    printf("%d \n",a);
    printf("%d \n",b); //报错，无法找到变量b
    return 0;
}

内存四区

数据存储范围和内存存储方向

堆冒泡排序

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

int * obtainArray(int len);
void initArray(int*arr,int len);
void printArray(int* arr,int len);
void buble(int* arr,int len);
void freeArray(int* arr);

int main(int argc, const char * argv[]) {
    // insert code here...
    int len = 10;
    int* arr = obtainArray(len);
    initArray(arr,len);
    printf("数组排序前：\n");
    printArray(arr, len);
    buble(arr, len);
     printf("\n 数组排序后：\n");
    printArray(arr, len);
    freeArray(arr);
    return 0;
}

/*
    构建一个堆区数组
 */
int * obtainArray(int len){
    return (int*)malloc(sizeof(int)*len);
}

/*
初始化数组的值
 */
void initArray(int*arr,int len){
    srand((unsigned int) time(NULL));
    for (int i = 0; i<len; i++) {
        *(arr+i) = rand()%100;
    }
}
/*
 打印数组信息
 */
void printArray(int* arr,int len){
    printf("\n");
    for (int i = 0; i<len; i++) {
        printf("  %d , ", arr[i]);
    }
}

/*
 冒泡排序法排序数组
 */
void buble(int* arr,int len){
    for (int i = 0; i<len; i++) {
        for(int j=0;j<len-1-i;j++){
            if(arr[j]>arr[j+1]){
                int tmp = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = tmp;
            }
        }
    }
}

    
void freeArray(int* arr){
    free(arr);
}

堆中操作字符串

int main(int argc, const char * argv[]) {
    //字符数组
    char stackArray[] = {'h','e','l','l','o',' ','w','o','r','l','d'};
    
    printf("字符数组stackArray的地址为%p \n:",stackArray);
    //字符串常量
    char* constArray = "hello world";
    printf("字符数组constArray的地址为%p \n:",constArray);
    //字符堆数组
    char* tuiArray = malloc(sizeof(constArray));
    strcpy(tuiArray, constArray);
    printf("字符数组tuiArray的地址为%p \n:",tuiArray);
    return 0;
}

内存操作函数

memset  
memcpy（源目的重叠，会出错误）
strcpy

memmove（源目的重叠，不会出错误）

    
int main(int argc, const char * argv[]) {
    int len = sizeof(int);
    printf("len = %d \n",len);
    int* arr = (int*)malloc(sizeof(int)*6);
    //使用memset初始化数组值
    memset(arr, 0, 24);
    memset(arr, 1, 8);
    for (int i = 0; i<2; i++) {
        arr[i]&=0x0000000f;
    }
    printArray(arr, 6);
    //使用memcpy复制数组值
    memcpy(arr+3, arr+1, 1);
    printArray(arr, 6);
    printf("\n");
    //对比memcpy和strcpy的使用
    char* p = "hello world";
    char newArr[] = "helloxx";
    char newArr2[] = {'h','l','l','h'};
    char newArr3[] = {'h','l','l','h','\0'};
    char* chArr = (char*)malloc(sizeof(*p));
    strcpy(chArr, p);
    printf("%s \n",chArr);
    
    strcpy(chArr, newArr);
    printf("%s \n",chArr);
  
    strcpy(chArr, newArr2);
    printf("%s \n",chArr);
    
    //注意当使用strcpy的时候，结束标志看src的'\0'标志位
    //字符数组中，没有标志位，需要显示添加
    strcpy(chArr, newArr3);
    printf("%s \n",chArr);
    //使用memmove移动数组的值
    
    //使用memcpy比较数组内容
    if(!memcmp(newArr2,newArr3, 4)){
        printf("newArr2 与 newArr3内容相等 \n");
    }
    
    
    if(memcmp(newArr2,newArr3, 5)){
        printf("newArr2 与 newArr3内容不相等 \n");
    }
    return 0;
}