环境表 内存管理-malloc()/free()

一 环境表

1 environ

所有的环境变量在程序中可以通过环境表获取。环境表是一个全局变量，类型是字符指针数组，以NULL结束，获取方式：
　　extern char** environ;
environ就是环境表的首地址，是全局变量

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

int main(){
    extern char** environ;//全局变量不建议改
    char** p = environ;//局部变量p可改
    while(*p/*!=NULL*/){//没有到结束
        printf("%s\n",*p);
        p++;
        printf("p=%p\n",p);
    }
    char* p1;//指针的移动由元素类型决定
    int* p2;
    printf("p1=%p,p1+1=%p\n",p1,p1+1);
    printf("p2=%p,p2+1=%p\n",p2,p2+1);
    p = environ;//移动到首地址
    char value[100] = {};
    while(*p){
        if(strncmp(*p,"LANG=",5)==0){
            strcpy(value,*p+5);
            break;
        }
        p++;
    }printf("%s\n",value);
}

2 环境变量的相关操作函数：

getenv() putenv() setenv() unsetenv() clearenv()

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

//命令中单词的个数argc,argv命令拆分出来的数组
//env就是环境表的首地址
int main(int argc,char** argv,char** env){
    extern char** environ;
    printf("env=%p,environ=%p\n",env,environ);
    char* value = getenv("LANG");
    printf("value=%s\n",value);
    putenv("VAR=ABC");
    printf("VAR=%s\n",getenv("VAR"));//ABC
    putenv("VAR=123");//存在就替换
    printf("VAR=%s\n",getenv("VAR"));//123
    setenv("VAR","456",0);//0 不替换
    printf("VAR=%s\n",getenv("VAR"));//123
    setenv("VAR","789",1);//1 替换
    printf("VAR=%s\n",getenv("VAR"));//789
    unsetenv("VAR");
}

---

二 Linux/Unix内存管理

1 linux/unix的内存相关函数和调用关系

STL -> 内存自动分配和自动回收
　|
C++ -> new/delete运算符 new分配 delete回收
　 |
C语言 -> malloc()分配 free()回收
　|
Unix系统函数 -> sbrk() brk() 分配和回收
　 |
Unix系统函数 -> mmap()分配 munmap()回收
| Unix/Linux的用户层内存关系
|
| 内核层(了解)
kmalloc() vmalloc()
　 |
get_free_page()
内存分配时，函数图由上到下调用。

2 进程内存空间

程序：在硬盘上的可以执行的文件
进程：在内存中运行起来的程序

一个进程的内存空间包括以下几个部分：
1 代码区: 程序的代码(函数)放入代码区，只读区
2 全局区：存放全局变量和static变量，main函数执行之前 分配全局区
3 BSS段: 存放未初始化的全局变量，main函数执行之前 清空BSS段(清0)。
4 栈区：非static的局部变量，包括函数的参数。栈区的内存 自动分配和自动回收。
5 堆区：也叫自由区，malloc()、free()就是操作堆区内存，程序员完全掌控堆区内存的分配和回收。
6 只读常量区：常量和字符串字面值(” “)，只读区，有些资料 没有分出只读常量区，而是统称为代码区。

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

int i1 = 1;//全局
int i2 = 2;//全局
int i3;//BSS段
static int i4 = 4;//全局
const int i5 = 5;//只读常量区

void fa(int i6){//i6栈  fa 代码区
  int i7;//栈
  static int i8 = 8;//全局
  const int i9 = 9;//栈
  int* pi = malloc(4);//堆
  int* pi2 = (int*)12345;/* pi2地址有但没有映射物理内存，不能存数据 *pi2 = 2；-> 段错误*/
  char* str = "abc";//只读常量区
  char str2[] = "abc";//栈
  printf("i6=%p\n",&i6);printf("i7=%p\n",&i7);
  printf("i8=%p\n",&i8);printf("i9=%p\n",&i9);
  printf("pi=%p\n",pi);printf("str=%p\n",str);
  printf("str2=%p\n",str2);  
}

int main(){
  printf("i1=%p\n",&i1);printf("i2=%p\n",&i2);
  printf("i3=%p\n",&i3);printf("i4=%p\n",&i4);
  printf("i5=%p\n",&i5);
  printf("fa=%p\n",fa);//fa 是函数指针
  fa(100);
  printf("PID=%d\n",getpid());//getpid取进程ID
  while(1);
}//cat /proc/进程ID/maps 

3 关于内存的地址（虚拟内存地址）

　　每个进程都先天设定了0-4G的虚拟内存地址(不是内存的真实地址，只是一个编号)，虚拟内存地址开始时不对应任何的内存，直接使用会引发段错误。程序员所接触的都是虚拟内存地址。虚拟内存地址必须映射物理内存(或者硬盘上的文件)以后才能 存储数据。
　　虚拟内存地址中，0-3G 是用户空间，是用户层使用，3G-4G 是内核空间，是内核层使用。用户层不能直接访问内核层，可以通过 Unix的系统函数访问内核层。UC课程主要研究 Unix系统函数。
　　内存管理的最小单位是一个内存页，每页大小是4096字节(4K),虚拟内存地址连续时，物理内存地址可以不连续。两个内存页的物理地址可能不挨着。即使只申请一个字节的内存，也会映射至少一个内存页。
　　多次申请内存时，第一次映射物理内存，后面不会再映射物理内存，除非内存使用完毕。

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

int main(){
    int x = 100;
  int* pi = &x;
    printf("pi=%p\n",pi);
    printf("*pi=%d\n",*pi);
    while(1);
}

proc2.c
#include <stdio.h>

int main(){
  int* pi = (int*)0xbfd1d08c;
    printf("pi=%p\n",pi);
  printf("*pi=%d\n",*pi);
}

　　Linux系统 把几乎一切都做成了文件，内存的情况也存成了文件。 /proc/进程ID/maps 文件存储了内存的分页情况。
cat /proc/进程ID/maps 就可以查看。
ps -aux 可以查看进程ID
maps 其实不是硬盘上的，是内存中的数据。

4 malloc和free

　　malloc()一次映射33个内存页，malloc分配内存时，除了数据区域外，还额外需要保存一些信息。底层有一个双向链表保存额外信息。

　　如果malloc累计的空间超过了33个内存页，会重新映射新的物理内存。free()并不保证一定会释放内存，如果到了最后33个内存页，等到进程结束才释放。

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

int main(){
  int a,b,c,d;
  printf("a=%p,b=%p,c=%p,d=%p\n",&a,&b,&c,&d);
  int* p1 = &a;
  *(p1+1000) = 100;//没有超过一页都可以使用
  //*(p1+1) 和 b和地址一样,但变量还是需要定义
  //原因是*(p1+N)不会重新映射内存，不能保证不会相互覆盖。
  printf("*(p1+1000)=%d\n",*(p1+1000));
  p1 = malloc(4);//4字节存数据,额外字节存附加
  int* p2 = malloc(4);
  int* p3 = malloc(4);
  printf("p1=%p,p2=%p,p3=%p\n",p1,p2,p3);
  //*(p1-1) = 0;//清空了上面4字节的内容
  free(p1);//free需要使用附加信息
}

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

int main(){
  printf("pid=%d\n",getpid());
  int* pi = malloc(4);
  printf("pi=%p\n",pi);
  *(pi+100) = 100;//能用但不推荐
  printf("*(pi+100)=%d\n",*(pi+100));
  int* pi2 = malloc(16*4096);
  int* pi3 = malloc(16*4096);
  printf("没超\n");
  printf("超了\n");
  int* pi4 = malloc(2*4096);//超了
  sleep(15);
  free(pi4); 
  printf("释放了2页\n");
  sleep(15);
  free(pi3);
  free(pi2); 
  free(pi);
  printf("全部释放\n"); 
  while(1);
}

　　如果一次申请的字节数超过33页，实际分配的内存页数会稍大于申请的页数，但和33就没关系。getpagesize()函数可以获取当前内存页的大小。

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

int main(){
  int size = getpagesize();
  printf("size=%d\n",size);
  int* p = malloc(size*35);//35个内存页
  printf("p=%p\n",p);//实际分配37个
  printf("pid=%d\n",getpid());
  while(1);
}

---

三 关于字符串赋值方式

= 改变地址，stcpy改变值。
如果不能改变地址的字符串(char[])赋值用strcpy
如果不能改变值的字符串(指向只读区)赋值用=

const 修饰的变量 值真的不能改么？
可以改，只要用 指针 指向就可以。
const int i = 10;
//i = 9;//错
int* pi = &i;
*pi = 9;//可以改 但不推荐使用

str.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(){
  char* s1 = "abc";//s1是地址 指向"abc"只读区
  char s2[] = "abc";//s2是数组，在栈中分配空间
  // 把"abc"的值 复制到了栈中，指向 栈区
  char* s3 = s2;//s3 指向了栈，不是常指针
 //strcpy(s1,"123");//错，s1指向只读区不能修改
  s1 = "123";   strcpy(s2,"123");
  //s2 = "123";//错，常指针不能改变 地址
  char* s4 = malloc(4);//s4指向堆 非 常指针
  //s4 = "abc";//改地址，s4 指向只读区
  strcpy(s4,"abc");//改值，正确的用法
  /* 字符串赋值操作中:
     = 改变的是地址，strcpy改的是值
     char[] 用strcpy赋值,char*指向只读区，用
     = 赋值，否则 用strcpy 赋值
 */
}