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;
}