指针和内存(01)

day 1-1

测试环境：Linux 2.6.32-279.el6.x86_64

测试代码：pointer.cpp

#include <stdio.h>

/**
 * test code: pointer.cpp
 * test environment: Linux 2.6.32-279.el6.x86_64
 *
 * 总结：
 * 1. 所有变量在声明时，系统都会为其分配一个内存地址
 * 2. 普通变量在内存中存放的是值
 * 3. 指针变量在内存中存放的是该指针指向的内存地址
 * 4. 指针变量的类型与指针变量所指向的内存空间存储的数据类型无关，
 *    使用者可以指定所需的类型去读取这些数据
 */
int main()
{
    // 声明一个类型为int的变量，且赋值为 17777
    int i = 17777;

    // 声明一个指针变量 ip，ip 指向的内存空间的数据类型为int
    // 指针变量存放的是其指向的内存地址，而不是值本身，此处 ip 存放的应该是变量 i 的地址
    // &i表示取变量 i 所在的内存地址
    int *ip = &i;

    // 声明一个类型为int的变量，且取指针变量 ip 的值并赋值给iv
    int iv = *ip;

    // 声明一个指针变量cp，(char*)表示需要按照char类型的读取方式去读取cp指向的内存空间(&i)中存储的数据
    // 此处按照char类型去读取 &i 则会对 &i 原来的4个字节进行截断，只读取1个字节的长度
    char *cp = (char*)&i;

    printf("%p: i=%d\n", &i, i);
    printf("%p: ip=%p\n", &ip, ip);
    printf("%p: iv=%d\n", &iv, iv);

    printf("%p: cp=%p, *cp=%c\n", &cp, cp, *cp);

    return 0;
}

编译 && 执行

g++ -g pointer.cpp -O0 -o pointer
./pointer

执行结果

调试过程

day 1-2

测试环境：Linux 2.6.32-279.el6.x86_64

测试代码：swap.cpp

/**
 * test code: swap.cpp
 * test environment: Linux 2.6.32-279.el6.x86_64
 * 总结：
 * 1. 在调用函数传参时，传的是变量的拷贝，而不是原始的值
 * 2. 在修改指针指向的内存空间存储的数据时，应使用操作符*
 * 3. 操作引用参数实际操作的是参数所引用的对象
 */

/**
 * 传进来的是main函数中变量a和b的值的拷贝 c1, c2
 * 交换的也是值的拷贝，并没有改变a和b内存空间中的数据，
 * 所以此函数并不能交换a和b的值
 */
void swap1(char c1, char c2)
{
    char tmp = c1;
    c1 = c2;
    c2 = tmp;
}

/**
 * 传进来的是main函数中变量a和b的内存地址的拷贝 cp1, cp2
 * 交换的也是内存地址的拷贝，并没有改变a和b内存空间中的数据，
 * 所以此函数并不能交换a和b的值
 */
void swap2(char *cp1, char *cp2)
{
    printf("in swap2: *cp1=%c, *cp2=%c\n", *cp1, *cp2);
    char *tmp = cp1;
    cp1 = cp2;
    cp2 = tmp;
    printf("out swap2: *cp1=%c, *cp2=%c\n", *cp1, *cp2);
}

/**
 * 传进来的是main函数中变量a和b的内存地址的拷贝 cp1, cp2
 * 然后通过操作符*来更新内存地址中的数据，所以此函数可以成功交换a和b的值
 */
void swap3(char *cp1, char *cp2)
{
    printf("in swap3: *cp1=%c, *cp2=%c\n", *cp1, *cp2);

    // 取c1指向的内存空间中的数据赋值给临时变量tmp
    char tmp = *cp1;
    // 取cp2指向的内存空间中的数据赋值到cp1指向的内存空间中，覆盖原有数据
    *cp1 = *cp2;
    // 将tmp的值赋值到cp2指向的内存空间中，覆盖原有数据
    *cp2 = tmp;

    printf("out swap3: *cp1=%c, *cp2=%c\n", *cp1, *cp2);
}

/**
 * 传进来的是main函数中变量a和b的引用cr1, cr2
 * cr1, cr2直接操作的是其引用的对象，所以此函数可以成功交换a和b的值
 */
void swap4(char &cr1, char &cr2)
{
    char tmp = cr1;
    cr1 = cr2;
    cr2 = tmp;
}

int main()
{
    char a = 'A';
    char b = 'B';
    printf("origin: a=%c, b=%c\n\n", a, b);

    swap1(a, b);
    printf("swap1: a=%c, b=%c\n\n", a, b);

    swap2(&a, &b);
    printf("swap2: a=%c, b=%c\n\n", a, b);

    swap3(&a, &b);
    printf("swap3: a=%c, b=%c\n", a, b);

    // 重置 a, b 为swap3交换之前的原值
    a = 'A';
    b = 'B';
    swap4(a, b);
    printf("swap4: a=%c, b=%c\n", a, b);

    return 0;
}

编译 && 执行

g++ -g swap.cpp -O0 -o swap
./swap

执行结果：

扫盲：

[k&r第1章第8节] In C, all function arguments are passed “by value.” This means that the called function is given the values of its arguments in temporary variables rather than the originals.
意思就是说在c语言里，所有的函数传参都是通过值传递：调用函数的时候传递过去参数值都是存放在临时变量中，而不是存放在原来的变量中。
所以在调用函数的时候，会根据参数列表创建相应的一些临时变量，然后将参数的值拷贝一份到临时变量中，也就是说被调用的函数不能直接修改主调函数中变量的值。

分析过程：

• 变量a和b的在内存中的情况：
  
  
  

• swap1中各个变量在内存中的情况：
  
  调用swap1(char c1, char c2)时，会产生和变量a, b对应的临时变量c1, c2（注意观察上图，这两个变量所占的内存空间的地址明显和a, b不一样），然后系统会将a, b的值分别赋值给c1, c2，此时不管swap1中如何操作c1, c2，都不会影响main函数中的变量a, b的值。
  -gdb调试过程：
  
  
  

• swap2中各个变量在内存中的情况：
  
  在调用swap2(char *cp1, char *cp2)时，会产生对应的两个临时指针变量cp1, cp2，然后系统会将&a, &b的值分别赋值给c1, c2，后续的一些操作在交换的是cp1和cp2指向的地址，并没有操作cp1和cp2指向的地址的值，因此不会影响main函数中的变量a, b的值。
  -gdb调试过程：
  
  
  

• swap3中各个变量在内存中的情况：
  
  在调用swap3(char *cp1, char *cp2)时，

  1. 会产生对应的两个临时指针变量cp1, cp2，程序会将&a, &b的值分别赋值给cp1, cp2
  2. 使用*cp1读取到cp1指向的内存空间中的数据赋值给临时变量tmp，此时tmp的值变为变量a的值
  3. 使用*cp2读取到cp2指向的内存空间中的数据（b的值），并将数据写到cp1指向的内存空间(&a)中，
     覆盖掉原来的数据(原来存放的是变量a的值)，此时cp1指向的内存空间中存储的就是b的值了，
     也就是说变量a里存放的数据变成了变量b的值
  4. 将tmp的值写到cp2指向的内存空间(&b)中，覆盖掉原来的数据(原来存放的是变量b的值)，此时cp2
     指向的内存空间中存储的就是tmp的值了，也就是说变量b里存放的数据变成了最开始的变量a的值
     -gdb调试过程：
     

• swap4中各个变量在内存中的情况比较简单，就不画图了，直接上gdb调试的图：
  -gdb调试过程：