rn_xtcxyczjh-2 通用+回调2 [查找最大值、求和 访问字符串（进程虚拟存储空间.段）]

2015.09.19 – 09.20
读xtcxyczjh（系统程序员成长计划）—- 学习程序设计方法。

本次笔记基于“rn_xtcxyczjh-I 功能 封装 通用 回调“中y15m914的代码。笔记中的表达极差。笔记基于的源代码保存地址为：pxtcxyczjh-SourceII。

2015.09.19 - 查找 求和

需求简述。
对一个存放整数的双向链表，找出链表中的最大值。
对一个存放整数的双向链表，累加链表中所有整数。

准备。
用回调函数的方法实现需求：双向链表提供遍历链表的功能（分内），找最大值和求和的功能留给用户自己编写（分外）。

代码。
指定（用户编写的）双向链表求和回调函数类型。
参数：双向链表节点中的元素（void ）；避免使用全局变量的额外参数（void ）。
返回值：void。

I 累积和
dlist.h（在dlist.h中定义双向链表值求和回调函数的类型）。

typedef void     (*pCallbackDlistVisitFunT)(void *ctx, void *data);

为使定义含义更明显，使用形参名（ctx为避免使用全局变量的额外参数，data为指向双向链表中数据的指针）。

dlist.c（在dlist.c中编写遍历双向链表节点（时调用双向链表求和的回调函数）的接口）。

/*dlist.c*///...... /* Visit every node of dlist */int dlist_foreach(pDlT pdl, pCallbackDlistVisitFunT pvisit, void *ctx){    unsigned int i, len;    if (NULL == pdl || NULL == pvisit)        return -1;    len = pdl->num;    pnd = pdl->pnd;    for (i = 0; i < len; ++i) {        pvisit(ctx, pnd->pe);        pnd = pnd->pn;    }    if (0 == i) return -1;    return 0;}

在dlist.h中声明dlist_foreach。

/*dlist.h*///...... int dlist_foreach(pDlT pdl, pCallbackDlistVisitFunT pvisit, void *ctx);

用户编写回调函数。
在其它文件如main.c中编写双向链表求和的回调函数。

/* Sum the integer data of dlist */static void sum_data2ctx(void *ctx, void *data){    long int *sum;    sum     = (long int *)ctx;    *sum    += *data;}

用户所有的回调函数暂时都只会在main中被调用，所以可将所有的回调函数都限制为static（避免全局函数名污染全局名字空间，造成重名等问题）。

改写dlist.c中的create_dlist()函数，让双向链表中的数据全为整型。

/*dlist.c*///……static int  itmp_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};//……/* Create len nodes for double linked list */pDlT create_dlist(unsigned int len){        //……    pf->pp  = pn;    pn->pn  = pf;    pn->pe  = &itmp_data[i-1];//原来的语句为pn->pe  = ctmp_data;    //……}

改写main函数，对双向链表求和。

/*main.c*//* Entry of C program */int main(void){    pDlT    pdl;    pNdT    pnd;    int i, len = 10;    long int sum = 0;    pdl     = create_dlist( len );    if (NULL == pdl)        return -1;    dlist_foreach(pdl, sum_data2ctx, &sum);    printf("Sum of dlist-I:%ld\n", sum);    for (i = 1; i <= len; ++i) {        pnd = alloc_node();        if (NULL == pnd) {            free_dlist(pdl);            return -1;        }        insert_node2dlist(pdl, pnd, i);    }    for (i = 1; i <=len; ++i) {        delete_node8dlist(pdl, i);    }    show_dlist(pdl, main_callback_show_dlist);    free_dlist(pdl);    return 0;}

修改dlist.c中显示双向链表元素的回调函数，让其正确显示链表内容。

/* dlist.c*/static void dlist_callback_show_dlist(pDlT pdl){    pNdT        pnd;    unsigned int    i, len;    len = pdl->num;    pnd = pdl->pnd;    for (i = 0; i < len; ++i) {        printf("%d ", *((int *)(pnd->pe)) );        pnd = pnd->pn;    }    //printf("%s", ((char *)(pnd->pe)) );    printf("\n");}

在linux终端编译、运行程序。

II 查找最大值回调函数
到了此时，只需要在main.c中定义一个pCallbackDlistVisitFunT类型的函数，然后在函数内完成查找链表最大值功能即可。

/* Get the max number from dlist */static void max_data8dlist(void *ctx, void *data){    int *max, a, b;    max     = (int *)ctx;    a       = *max;    b       = *((int *)data);    *max    = a > b ? a : b;}

*ctx的初始值为双向链表的第一个元素。在main.c中访问不到双向链表的元素，故而在dlist.c中添加一个返回双向链表第i个元素的函数。

/* Get the i-th element of dlist */void * get_dlist_ith_elmt(pDlT pdl, unsigned int i){    int     len;    pNdT    pnd;    if (NULL == pdl)        return NULL;    len = pdl->num;    if (0 == len)        return NULL;    pnd = pdl->pnd;    for (i = 1; i < len; ++i)        pnd = pnd->pn;    return pnd->pe;}

并将get_dlist_ith_elmt函数声明在dlist.h中。

/*dlist.h*/void * get_dlist_ith_elmt(pDlT pdl, unsigned int i);

在main.c中测试求双向链表最大值的回调函数。

/* main.c *///……/* Entry of C program */int main(void){    pDlT    pdl;    pNdT    pnd;    int i, max, len = 10;    long int sum = 0;    pdl     = create_dlist( len );    if (NULL == pdl)        return -1;    // 获取双向链表中所有元素的和    dlist_foreach(pdl, sum_data2ctx, &sum);    printf("Sum of dlist-I:%ld\n", sum);    // 获取双向链表的第一个元素给max，然后找双向链表中的最大值    max = *(int*)get_dlist_ith_elmt(pdl, 1);    dlist_foreach(pdl, max_data8dlist, &max);    printf("The max value-I:%d\n", max);    //……    return 0;}

在linux终端编译运行程序。

源代码目录。
../xtcxyczjh/y15m9d19/

2015.09.20 – 字符串大小写转换

需求简述。
对一个存放字符串的双向链表，把存放在其中的字符串转换成大写字母。

准备。
字符串转换的功能不属于双向链表分内之事 + 处理双向链表的通用性，采取用dlist_foreach()函数回调用户编写的将字符串转换成大写字母的函数lstr2ustr()。在站在调用者的调度来编写回调函数lstr2ustr()。之前先修改一个问题：双向链表的值只能在dlist.c中的create_dlist()函数中指定，调用者并不能决定每个链表中的值。现在修改双向链表的相关接口，然调用者决定往链表存什么值。

在创建双向链表时将双向链表中的所有元素都循环初始化为1，2, …, 0。

/* dlist.c *///……pDlT create_dlist(unsigned int len){    //…    //For doubly linked list node default    static int  itmp_data[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 0};    int ID_SIZE = 10;    //……    for (i = 1; i < len; ++i){        //…...        pp->pe  = &itmp_data[(i - 1) % ID_SIZE];        //…...    }    //……    pn->pe  = &itmp_data[(i - 1) % ID_SIZE];    //……    return pdl;}

将双向链表默认初值放在函数内部，避免全局变量。编译、运行程序，跟先前一样的结果。

然后提供一个可以初始化双向链表中任意一个节点的函数。

/* dlist.c *///….../* Assign i-th node */int assign_ith_node_value(pDlT pdl, void *data, unsigned int i){    pNdT        pnd;    unsigned int k, len;    if (NULL == data)        return -1;    len = pdl->num;    if (len < 1 || i < 1 || i > len)        return -1;    pnd = pdl->pnd;    for (k = 1; k < i; ++k)            pnd = pnd->pn;    pnd->pe = data;}   

在dlist.h中声明此函数。

在main函数中将双向链表初始化为字符串序列。

/* main.c */#include "dlist.h"#include <stdio.h>#include <ctype.h>#include <string.h>#include <stdlib.h>static void main_callback_show_dlist(void *data, unsigned int len);static void sum_data2ctx(void *ctx, void *data);static void max_data8dlist(void *ctx, void *data);#define DLIST_SIZE 10/* Entry of C program */int main(void){    pDlT    pdl;    //pNdT  pnd;    char    *pstr[DLIST_SIZE];    int i, j, max, slen, len = DLIST_SIZE;    long int sum = 0;    char *str[DLIST_SIZE] = {"i", "love", "you", "once", "i", "love", "you", "twice", "i", "love"};    pdl     = create_dlist( len );    if (NULL == pdl)        return -1;    // 获取双向链表中所有元素的和    dlist_foreach(pdl, sum_data2ctx, &sum);    printf("Sum of dlist-I:%ld\n", sum);    // 获取双向链表的第一个元素给max，然后找双向链表中的最大值    max = *(int*)get_dlist_ith_elmt(pdl, 1);    dlist_foreach(pdl, max_data8dlist, &max);    printf("The max value-I:%d\n", max);    // 将字符串载入RAM中    for (i = 0; i < DLIST_SIZE; ++i){        slen    = strlen(str[i]);        pstr[i] = (char *)malloc(slen + 1);        if (NULL == pstr[i]) {            for (j = i - 1; j >= 0; --j)                free(pstr[j]);            free_dlist(pdl);            return -1;        }        memcpy(pstr[i], str[i], slen + 1);    }    // 将RAM中的字符串一次赋值给双向链表的节点    for (i = 0; i < len; ++i)        assign_ith_node_value(pdl, pstr[i], i + 1);    show_dlist(pdl, main_callback_show_dlist);    for (i = 0; i < DLIST_SIZE; i++)        free(pstr[i]);    free_dlist(pdl);    return 0;}/* Callback function for show_dlist() */static void main_callback_show_dlist(void *data, unsigned int len){    printf("%s ", ((char *)data) );}/* Sum the integer data of dlist */static void sum_data2ctx(void *ctx, void *data){    long int *sum;    sum     = (long int *)ctx;    *sum    += *((int *)data);}/* Get the max number from dlist */static void max_data8dlist(void *ctx, void *data){    int *max, a, b;    max     = (int *)ctx;    a       = *max;    b       = *((int *)data);    *max    = a > b ? a : b;}

在main程序中，str[i]指向的的内容.rodata段中，保存在.rodata中的字符串不允许被修改。所以要将str中的内容拷贝到RAM中。

在linux终端编译、运行程序。

另外，在创建新的节点时，插入节点的值可由调用者传入。

/* dlist.c */ //….../* Allocate one node of doubly linked list */pNdT alloc_node(void *data){    pNdT    pnd;    pnd     = (pNdT)malloc( sizeof(NDT) );    if (NULL != pnd) {        pnd->pe = data;    }    return pnd;}

在dlist.h中更新alloc_node函数的声明。

现在可以来实现将双向链表中的字符串转换为大写的了。在main.c中编写回调函数lstr2ustr()。

/* main.c *///......#include <stdlib.h>//……/* Translate lower string to upper string */static void lstr2ustr(void *ctx, void *data){    char ch, *str;    str = (char *)data;    ch  = *str;    while (ch) {        if (islower(ch))            *str    = toupper(ch);        ++str;        ch  = *str;    }}

‘a’是一个字符常量，它的值在任何时候都 是97，但在不同语言中，97却不一定表’a’。我们不能简单的认为在97(‘a’)-122(‘z’)之间的字符就是小写字母，而是应该调用标准C函 数islower来判断，同样转换为大写应该调用toupper而不是减去一个常量。

回调函数lstr2ustr()的类型为pCallbackDlistVisitFunT。调用库函数来转换字符而不是用常量，这些函数在

/* main.c *///……int main(void){    //……    show_dlist(pdl, main_callback_show_dlist);        // 将双向链表中的字符串转换为大写        dlist_foreach(pdl, lstr2ustr, NULL);        show_dlist(pdl, main_callback_show_dlist);    //…..    Return 0;}

在linux终端编译、运行程序。

源代码目录。
../xtcxyczjh/y15m9d20/

一个Linux进程的虚拟存储空间。

来自《CSAPP》 2E-9.7.2

.bss
未初始化的全局变量(.bss段)用来存放那些没有初始化的和初始化为0的全局变量的。bss类型的全局变量只占运行时的内存空间，而不占用文件空间（可执行文件中记录了.bss段的大小）。

.data
初始化过的全局变量 (.data段)用来存放那些初始化为非零的全局变量。data类型的全局变量是即占文件空间，又占用运行时内存空间的。

.text
text段存放代码(如函数)和部分整数常量。

.rodata
rodata的意义同样明显，ro代表read only，rodata就是用来存放常量数据的。关rodata类型的数据，要注意以下几点：
(1)常量不一定就放在rodata里，有的立即数直接和指令编码在一起，存放在代码(.text)中。
(2)对于字符串常量，编译器会自动去掉重复的字符串，保证一个字符串在一个可执行文件(EXE/SO)中只存在一份拷贝。
(3)rodata是在多个进程间是共享的，这样可以提高运行空间利用率。
(4) rodata是在多个进程间是共享的，这样可以提高运行空间利用率。
(5) 在有的嵌入式系统中，rodata放在ROM(或者norflash)里，运行时直接读取，无需加载到RAM内存中。
(6) 在嵌入式linux系统中，也可以通过一种叫作XIP（就地执行）的技术，也可以直接读取，而无需加载到RAM内存中。
(7) 常量是不能修改的，修改常量在linux下会出现段错误。
这些机制由编译器（和操作系统）共定。

把在运行过程中不会改变的数据设为rodata类型的是有好处的：在多个进程间共享，可以大大提高空间利用率，甚至不占用RAM空间。同 时由于rodata在只读的内存页面(page)中，是受保护的，任何试图对它的修改都会被及时发现，这可以提高程序的稳定性。字符串会被编译器自动放到rodata中，其它数据要放到rodata中，只需要加const关键字修饰就好了。

Stack
栈用于存放临时变量和函数参数。根栈相关的笔记有“ 一个C源文件到可执行文件 [反汇编-函数栈帧 编译 链接]”、“ [Hb-XVII] 计算机的抽象层次-简 使用寄存器 使用内存空间 程序执行过程 使用main函数规定 不定参数函数机制 C”、“ [CSAPP-I] 过程（函数栈帧） C语句的机器级表示（gcc -S）”。

Heap
堆是最灵活的一种内存，它的生命周期完全由使用者控制。使用堆内存时请注意两个问题：

• malloc/free要配对使用。内存分配了不释放我们称为内存泄露(memory leak)，内存泄露多了迟
  早会出现Out of memory的错误，再分配内存就会失败。当然释放时也只能释放分配出来的
  内存，释放无效的内存，或者重复free都是不行的，会造成程序crash。
• 分配多少用多少。分配了100字节就只能用100字节，不管是读还是写，都只能在这个范围
  内，读多了会读到随机的数据，写多了会造成的随机的破坏。这种情况我们称为缓冲区溢出
  (buffer overflow)，这是非常严重的，大部分安全问题都是由缓冲区溢出引起的。

linux下检查内存泄露或缓冲区溢出的工具

valgrind

读《xtcxyczjh》-Part-II pnote over.
[2015.09.21-15:31]