有些时候,我们常常会碰到一些从字符串中取数据的问题,如果取固定个数的数值还好,利用sscanf就可以实现,但倘若遇到从字符串中取数组,且数组个数不固定的情况就比较麻烦了.
比如构造一个矩阵,其值从文件set.txt中读取
1 2 3
4 5 6
7 8 9
此文件中含有3*3的矩阵,当然也可能是n*n,那如何才能灵活地从文件中读取数据,构造各种大小的数组呢?
经过查找,我发现了strsep函数,
***************************************************************************************************************
函数：char * strtok_r (char *newstring, const char *delimiters, char **save_ptr)
    就象strtok函数一样，strtok_r函数能够连续调用，以将一个字符串分解成为几个token。不同的时下一个strtok_r函数不会破坏这个函数的状态。因为它提供了一个指向不同函数的**save_ptr指针。
    这个函数是POSIX.1b提出的建议，它被许多系统支持，以提供多线程的字符分解。
    函数：char * strsep (char **string_ptr, const char *delimiter)
    另一个可重入的方法是取消了第一个参数。初始时的指针由用户指定，后面调用的指针则由delimiter决定。返回下一个被分解的token。
    这个函数是在4.3BSD系统中引入的，因此被广泛使用着。
以下是一个使用strsep的实例：
#include <string.h>
#include <stddef.h>
...
char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *running;
char *token;
...
running = string;
token = strsep (&running, delimiters);    /* token => "words" */
token = strsep (&running, delimiters);    /* token => "separated" */
token = strsep (&running, delimiters);    /* token => "by" */
token = strsep (&running, delimiters);    /* token => "spaces" */
token = strsep (&running, delimiters);    /* token => "and" */
token = strsep (&running, delimiters);    /* token => "punctuation" */
token = strsep (&running, delimiters);    /* token => NULL */
****************************************************************************************************************
这个说明不是很明确,我自己写了个程序来使用这个函数
#include <stdio.h>
#include <string.h>
int main(){
FILE *fp;
char str[20],*tmp,*substr="a";
int t,data[5];
const char delimiters[]=" ";
Matrix<int> m;
List<Matrix<int> > l;
fp = fopen("set.txt","r");
while(fgets(str,20,fp)!=NULL){
substr = str;
int i=0;
token = str;
while(token!=NULL){
      token = strsep(&substr," ");
      if(*token=='\n')
         break;
      datas[i++]=atoi(token);
  }
m.setValue(datas);
l.insert(m);
  }
fclose(fp);
return 0;
}
此程序每从文件中取到一行数值,将其置入一个数组内,再将此数组置入矩阵中.
这里要注意这样几个问题:
1,每行数值后需要多加一个分隔符,否则会取到\n值,在linux下,文本是这样构成的
    a b c\n
    因此,若不在最后加空格,最后一个token取到的为c\n,因此取要在最后一个字符后加一个分隔符,此处为空格
2, 初始时,需要对token置任意值,,这样的话才可以开始循环.
3,数组的大小,我是这样设定的,我在文件头放置固定字符值,用以明确数组的大小.依照此值生成动态数组即可

5.字符串与数组工具
    在许多程序中，字符串（或字符数组）是很重要的一部分。在GNU C库中提供了广泛字符串工具函数，包括字符串复制、串联、比较、搜索。这些函数中的大多数都能够在内存的任何地方操作；例如，函数memcpy能够用于任何一种数组中拷贝内容。
    通常，一些C语言的初学者是直接将这些复制到自己的代码中，但当他们越来越熟悉的时候，在使用这些函数时，通常考虑更多的是可维护性、效率和可移植性。
    举例说，你可以在两行C代码中比较两个字符串，但如果你使用内置strcmp函数，你出错的机会会更少。同时，由于这些库函数是经过了优化的，所以使用它们会使你的程序运行得更快。
    5.1字符串表示法
    这个小节是对一个C程序设计初学者做一个关于字符串概念的概要介绍。这里将说明在C语言中如何表示一个字符串，以及一些通常的缺陷。如果你已经很熟悉它们，可以跳过这一小节。
    一个字符串是字符数组。但字符串变量通常被说明成一个字符型指针char *。这种字符串变量不包括空格符，它将被存话在内存中的某个地方，或者是一个常量，或者是一个动态分配的内存。在内存中的地址将存入这个指针变量，当然，你也可以将一个空指针存入指针变量。空指针没有指向任何东西，所以用空指针表示字符串将出错。
    按习惯，在字符串后面加上一个空字符“。例如，你想测试字符型指针p是不是指向一个以空字符结束字符串，你可以使用!*p或*p=’ '。
     一个空字符与一个空指针在概念上是很不同的，尽管它们都表示为整数0。
字符串在C语言源程序中，将其包含在双引号（" "）之内。在ISO C中，"a" "b"与"ab"相同。在GNU C中不允许修改字符串中的内容，因为它是被存放为只读的。
    字符数组如果声明为const，则不能修改。而通常更好的方法是将其定义为const char *类型，因为这样，C编译器会检测到想修改这个字符串的企图。
    通常字符数组在分配内存时，会加上一个用于存放空字符串（这个空字符串用来标识字符串结束）。在这个文档中，内存分配大小（allocation size）用来表示这个字符串所占用的内存总和，而长度（length）则用来表示不包括空字符在内的总长度。
    尝试往字符串变量中存放超过其分配大小的字符是一个声名狼籍的程序错误。当你在编写程序时，请一定要提起注意。有许多库函数可以帮助你完成这个任务。另外，请牢记，你需要为表示字符串终了的空字符留下一个内存空间。
5.2字符串与数组函数的惯例
    这一小节将描述所有基于任意数组或任意内存块的函数，讲述这些函数的一些通性的东西。
    对任意内存块操作的函数的名字都是以mem开头的（如memcpy），并且总是带上一个参数，用来指定所操作的内存块大小。这些函数返回 void *类型的数组，数组的成员是bytes型的。你可以传送任何一种类型的指针给这些函数，而且可以使用sizeof操作符来计算它的大小。
    相对应的，专门处理字符串的函数则是以str开头的（如strcpy），这些函数都是以用空字符结束的字符串代替显式的size参数。（虽然有些函数也接受指定的最大长度，但它们同样要检测结束字符串的空字符。这个函数返回char *类型的数组，这些数组的成员是char型的。
    5.3字符串长度
    我们可以使用strlen函数获得一个字符串的长度。这个函数在头文件string.h中声明。
    函数：size_t strlen(const char *s)
    这个函数将返回以空字符结束的字符串s的长度。
    例如：
    strlen ("hello, world")    （值为12，加上一个空字符）
    当用于字符数组时，strlen函数将返回已存放的字符串内存分配大小，而非整个数组的内存分配大小。我们可以使用sizeof操作符来获取字符数组的内存分配大小：
    char string[32] = "hello, world";
    sizeof (string) （其值为32）
    strlen (string) （其值为12，加上一个空字符）
    5.4复制与联接字符串
    我们可以使用这一小节中的函数复制字符串和字符数组中的内容，或者将一个字符串的内容附加到另一个字符串中去。这些函数在头文件string.h中声明：
    有一个规律可以帮助你记住这一小节中所有函数的参数位置：目标数组都在源数组的左边！所有的函数都返回目标数组的地址。
    如果源数组与目标数组或在物理地址上有重迭的话，大多数函数都无法正常地工作。例如，如果目标数组的头与源数组的尾在物理地址上重迭，那么源数组中的一部分内容就会在复制之前被覆盖。甚至可能出现使得标识字符串结束的空字符丢失，而使拷贝无休止地无意义地进行着。
    所有会因为这个问题而出错的函数，都会在本手册中显式标识出来。除了这个小节里的函数外，还有sprintf函数（参见格式化输出函数章节）以及scanf函数（参见格式化输入函数章节）。
    函数：void * memcpy (void *to, const void *from, size_t size)
这个函数会从数组from的开头处，复制size个字符，并从头写入数组to中。这个函数的参数from和to如果是有重迭的两个数组，那么就会出错。这种情况，请使用memmove函数来代替它。
    Memcpy函数返回to的地址；
    以下是一个使用memcpy复制一个数组中内容的例子：
    struct foo *oldarray, *newarray;
    int arraysize;
    ...
    memcpy (new, old, arraysize * sizeof (struct foo));
    函数：void * memmove (void *to, const void *from, size_t size)
    从from中拷贝size字节到to中，即使这两个内存块有重迭也不影响执行效果。
    函数：void * memccpy (void *to, const void *from, int c, size_t size)
    这个函数将从form中拷贝不超过size字节到to中去，在拷贝中如果有一个字节与c匹配，就中止拷贝。该函数将返回一个指针。如果在拷贝时发现了c，这个指针指向to，如果没有，就是一个空指针。
    函数：void * memset (void *block, int c, size_t size)
    该函数将复制size个c（转换成为char型）到block中，返回block的值。
    函数：char * strcpy (char *to, const char *from)
    复制字符串from到字符串to中去。就象memcpy一样，这个函数也无法处理两个字符串有重迭部分的情况。该返回to的值。
    函数：char * strncpy (char *to, const char *from, size_t size)
    这个函数与strcpy类似，区别在于strncpy将精确地拷贝size字节到to中去。
如果from的长度大于size，那么strncpy仅拷贝from中的前size个字符。要注意的是，这种情况下，将不会往to中写入表示结束的空字符。
如果from的长度小于size，那么strncpy将拷贝from中所有内容，然后加上一些空字符，使其够size字节。这是十分有用的，但仅在ISO C中可用。
    Strncpy也无法正确处理from和to有重迭的情况。
    使用strncpy代替strcpy可以避免尝试对to所分配空间之后的操作。但是，如果你要把一个较小的字符串，写到一个大的缓冲中，会使你的程序运行得更慢，因为这时由于size很大，程序花了许多时间做无谓的工作：填写大量的空字符。
    函数：char * strdup (const char *s)
    拷贝一个以空字符结束的字符串到一个新分配的字符串中。这个新字符串将自动调用malloc函数来分配。如果malloc函数无法为这个新字符串分配空间，strdup将返回一个空指针。如果能够为其分配空间，将返回这个新字符串的地址指针。
    函数： char * strndup (const char *s, size_t size)
    它与strdup类似，区别在于strndup将复制不多于size字节的字符到新字符串中。
    如果s的长度大于size，那么strndup将复制size个字符，再添上一个空字符串。否则，就会完整地被复制。
    这个函数与strncpy不同的是，它将保证拷贝出来的字符串一定有表示结束的空字符。
    函数：char * stpcpy (char *to, const char *from)
    与strcpy类似，区别在于，stpcpy将返回一个指向字符串to结尾的指针（也就是，指向那个表示结束的空字符），而不指向字符串的开始。
例如，下面这个程序使用stpcpy将’foo’和’bar’连接成为’foobar’，然后再打印出来：
#include <string.h>
#include <stdio.h>
int
main (void)
{
  char buffer[10];
  char *to = buffer;
  to = stpcpy (to, "foo");
  to = stpcpy (to, "bar");
  puts (buffer);
  return 0;
}
    这个函数不属于ISO和POSIX标准，所以并不经常在UNIX系统上使用，但别自己去创建这个函数，因为可能在MS-DOS中就有。
    这个函数也无法正确处理两个字符串有重迭部分的情况。
    函数：char * stpncpy (char *to, const char *from, size_t size)
    它与stpcpy类似，区别在于，stpncpy将精确地只拷贝size个字符。
如果字符串from的长度比size大，那么stpncpy将只复制前size个字符，然后返回一个指向最后拷贝的那个字符的地址。要注意的是，在这种情况下，最后并没有一个表示字符串结束的空字符。
    如果from的长度小于size，那么，stpncpy将拷贝from中的所有字符串，然后在后面加上（size-form长度）个空字符。它将返回一个指向第一个空字符的指针。
    这个函数并不属于ISO和POSIX标准，但却在GNU C库的开发经常用到。
它也无法正确地处理源、目标两个字符串有重迭部分的情况。
    函数：char * strdupa (const char *s)
    它与strdup函数十分类似，区别在于，它不使用malloc来分配一个新字符串，而是使用alloc来分配。
    很明显，strdupa仅适合于宏，也就是你无法获得这个函数的地址。虽然有这个限制，但还是有它有用的一面。下面这个程序说明的有时使用malloc将付出更大的代价。
#include <paths.h>
#include <string.h>
#include <stdio.h>
const char path[] = _PATH_STDPATH;
int
main (void)
{
  char *wr_path = strdupa (path);
  char *cp = strtok (wr_path, ":");
  while (cp != NULL)
     {
      puts (cp);
       cp = strtok (NULL, ":");
     }
  return 0;
}
    请注意直接使用目录调用strtok是非法的。
    这个函数仅在GNU C中能够使用。
    函数：char * strndupa (const char *s, size_t size)
    完成功能与strndup类似，不过它像strdupa一样使用alloca来为新字符串分配内存空间。它的优缺点与strdupa一样。
这个函数也只能用于宏，因为无法得到这个函数的地址。
    它仅在GNU C中能够使用。
    函数：char * strcat (char *to, const char *from)
    与strcpy类似，区别在于，它是将字符串from中的内容增加到字符串to的后面。而不是覆盖字符串to。字符串from中的第一个字符将覆盖掉to中原来最后的空字符。
    以下是一个与strcat等价的定义：
char *
strcat (char *to, const char *from)
{
  strcpy (to + strlen (to), from);
  return to;
}
    它无法正确处理from与to两个字符串有重迭部分的情况。
    函数：char * strncat (char *to, const char *from, size_t size)
    它与strcat类似，区别在于附加到字符串to后面的字符将不超过size个。在to的最后将保证有一个空字符，也就是说添加后，总的分配空间将新增size+1。
    这个函数可以使用下面这个程序实现：
char *
strncat (char *to, const char *from, size_t size)
{
  strncpy (to + strlen (to), from, size);
  return to;
}
    同样的，它也无法正确处理from与to有重迭部分的情况。
    以下是一个使用strncpy和strncat函数的实例。注意它们使用的方法，如何避免size过大。
#include <string.h>
#include <stdio.h>
#define SIZE 10
static char buffer[SIZE];
main ()
{
  strncpy (buffer, "hello", SIZE);
  puts (buffer);
  strncat (buffer, ", world", SIZE - strlen (buffer) - 1);
  puts (buffer);
}
    这个程序的输出为：
hello
hello, wo
    函数：void * bcopy (void *from, const void *to, size_t size)
    这个函数已经被memmove取代，它起源于BSD系统。注意，它并不等同于memmove函数，参数的顺序不同。
    函数：void * bzero (void *block, size_t size)
    这个函数已经被memset取代，它起源于BSD系统。注意，它并不如memset那么通用，因为bzero只能存入0值。
    5.5字符串与数组的比较
    你可以使用这一小节里的函数进行字符串或字符数组内容比较。它们不仅可以用来检查字符串是否相同，还可以在字符串排序时起作用。
    与C语言的其它函数不大相同，字符串比较函数返回非零值，是表示它们不相等，而非相等。返回值是负数代表第一个字符串小于第二个字符串，如果返回的是正数则代表第一个字符串大于第二个字符串。
    这些函数通常仅用于检查两个字符串是否相等。如：`! strcmp (s1, s2)'.
    所有的这些函数都在头文件string.h中声明。
    函数：int memcmp (const void *a1, const void *a2, size_t size)
    函数memcmp用于比较字符串s1与s2的前size个字符。
    如果两上字符块相同，memcmp将返回0。
    对于任意的字符数组，memcmp函数通常用于测试它们是否相等。而不常进行byte-wise的字符串比较。如果是byte-wise比较，将返回一个表示两个字符串之间的关系的浮点数。
    如果要比较的对象中包含一些由于边界对齐需求而填入结构对象中的空格、联合(union)结束的额外空格、字符串所分配的空间未使用完的部分引起的“holes”的话，最好使用memcmp来完成。这些“holes”的内容是不确定的，在执行byte-wise比较时结果也是不明确的。
    例如，给出一个如下的结构定义：
struct foo
  {
    unsigned char tag;
    union
       {
         double f;
        long i;
          char *p;
       } value;
  };
    如果你要比较两个struct foo对象的话，建议最好使用memcmp。
    函数：int strcmp (const char *s1, const char *s2)
    这个函数用来比较s1和s2字符串，这个函数将返回一个值，它的符号与第一对不同的字符的比较结果相关。
    如果两个字符串相等的话，strcmp将返回0。
    如果s1是s2的一个子串的话，s1小于s2。
    函数：int strcasecmp (const char *s1, const char *s2)
    与strcmp类似，不同之处在于，strcasecmp不区分大小写。
    Strcasecmp源于BSD系统。
    函数：int strncasecmp (const char *s1, const char *s2, size_t n)
    与strncmp类似，不同之处在于，strncasecmp不区分大小写。
    Strncasecmp是GNU扩展函数。
    函数：int strncmp (const char *s1, const char *s2, size_t size)
    此函数与strcmp极为类似。不同之处是，strncmp函数是指定比较size个字符。也就是说，如果字符串s1与s2的前size个字符相同，函数返回值为0。
    这里是两个使用strcmp和strncmp的实例。在本例中，假定使用ASCII字符集（如果你是使用其它字符集--如EBCDIC--的话，返回的值可能不同，因为在不同的字符集中顺序不同。）
strcmp ("hello", "hello")
    => 0    /* 这两个字符串相同。 */
strcmp ("hello", "Hello")
    => 32   /* 大小写敏感，h-H=32 */
strcmp ("hello", "world")
     => -15  /* h-w=-15 */
strcmp ("hello", "hello, world")
     => -44  /* 空字符与逗号不同 */
strncmp ("hello", "hello, world", 5)
    => 0    /* 前5个值是相同的，所以返回0 */
strncmp ("hello, world", "hello, stupid world!!!", 5)
     => 0    /* 前5个值是相同的，所以返回0 */
    函数：int bcmp (const void *a1, const void *a2, size_t size)
    这是一个过时的memcmp函数的别名，起源于BSD。
    5.6 Collation函数
    在相同的地区，词典序与严格的字符序不尽相同。例如，在西班牙文字中常不考虑整理的需要，使用一些标识来表示重音。另一方面，字符序列“ll”将被认为是一个单独的字符“l”。
    我们可以使用strcoll和strxfrm函数（在头文件string.h中声明）来实现按当地字符序来整理并比较字符串。使用的不同地区的字符集，可在LC_COLLATE类中设置，具体参见地区和国际化那一章节。
    在标准C方言中，strcoll与strcmp相同。
    使用这些函数进行比较时，它们需先将字符串映射成为本地字符序，然后再进行比较。
    函数strcoll为了完成这样的比较，会自动地暗中完成这个映射工作。与此相反，strxfrm函数则是明确地完成映射。如果你要使用一个相同的字符串进行多次比较，那么更有效的方法可能是使用strxfrm函数将它们一次转换完成，尔后再使用strcmp进行比较。
    函数：int strcoll (const char *s1, const char *s2)
    此函数与strcmp类似，区别在于，它使用本地字符充（LC_COLLATE设置的）。
    以下是一个字符串排序的例子，在此例中使用了strcoll进行字符串比较。实际的排序算法未在此处写出，它出自qsort（参见数组排序函数小节）。以下的代码仅说明比较的工作。（在本节的后面部分，还可以看到使用strxfrm实现）。
/* This is the comparison function used with qsort. */
int
compare_elements (char **p1, char **p2)
{
  return strcoll (*p1, *p2);
}
/* This is the entry point--the function to sort
    strings using the locale's collating sequence. */
void
sort_strings (char **array, int nstrings)
{
  /* Sort temp_array by comparing the strings. */
  qsort (array, sizeof (char *),
          nstrings, compare_elements);
}
    函数：size_t strxfrm (char *to, const char *from, size_t size)
    函数strxfrm根据本地字符集进行转换、整理，然后存入数组中。它只转换前size个（包括结束的空字符），并存盘。
    要注意的是，当from和to有重迭部分将导致结果不明确。参见复制与连接小节。
    这个函数的返回值是转换后的字符长度。这个值不受size的影响，但如果返回值大于或等于size的话，表示并未转换完数组中所有的内容。在这种情况下，你仅能得到部分转换的值，如果要整个字串，则带上一个更大的size，重新调用一遍strxfrm。
    转换完后的字符串可能比原来的字符串长，也可能更短。
    如果size是0的话，将没有字符串被转换。在这种情况下，strxfrm简单地返回字符串的字符个数。这对于决定需要多少的存储空间十分有用。
这儿是一个使用strxfrm进行多次字符串比较的例子。它完成与上例中一样的功能，但运行得更快，因为strxfrm将转换工作一次完成，无须每次比较时进行转换。
struct sorter { char *input; char *transformed; };
/* This is the comparison function used with qsort
      to sort an array of struct sorter. */
int
compare_elements (struct sorter *p1, struct sorter *p2)
{
  return strcmp (p1->transformed, p2->transformed);
}
/* This is the entry point--the function to sort
      strings using the locale's collating sequence. */
void
sort_strings_fast (char **array, int nstrings)
{
  struct sorter temp_array[nstrings];
  int i;
  /* Set up temp_array.  Each element contains
      one input string and its transformed string. */
  for (i = 0; i < nstrings; i++)
     {
      size_t length = strlen (array[i]) * 2;
       char *transformed;
         size_t transformed_lenght;
      temp_array[i].input = array[i];
       /* First try a buffer perhaps big enough.  */
          transformed = (char *) xmalloc (length);
      /* Transform array[i].  */
       transformed_length = strxfrm (transformed, array[i], length);
      /* If the buffer was not large enough, resize it
          and try again.  */
         if (transformed_length >= length)
         {
           /* Allocate the needed space. +1 for terminating
              NUL character.  */
           transformed = (char *) xrealloc (transformed,
                                           transformed_length + 1);
         /* The return value is not interesting because we know
              how long the transformed string is.  */
            (void) strxfrm (transformed, array[i], transformed_length + 1);
           }
          temp_array[i].transformed = transformed;
       }
  /* Sort temp_array by comparing transformed strings. */
   qsort (temp_array, sizeof (struct sorter),nstrings, compare_elements);
  /* Put the elements back in the permanent array
      in their sorted order. */
  for (i = 0; i < nstrings; i++)
     array[i] = temp_array[i].input;
  /* Free the strings we allocated. */
       for (i = 0; i < nstrings; i++)
   free (temp_array[i].transformed);
}
    兼容性提示：字符串collation函数是ISO C的新功能。老的C版本无此功能。
    5.7查找函数
    这一小节讲述一些字符串、字符数组内进行各种各样的搜索操作的函数，这些函数在头文件string.h中声明。
    函数：void * memchr (const void *block, int c, size_t size)
    此函数在字符串block的前size的字符中查找字符c（参数的数据类型是int，运行是将转换成为cahr类型）。如果找到，该函数将返回指向这个值的指针；如果无匹配的结果，将返回空指针。
    函数：char * strchr (const char *string, int c)
    此函数在字符串string（以空字符结束的字符串）中查找字符c参数的数据类型是int，运行是将转换成为cahr类型）。如果找到，该函数将返回指向这个值的指针；如果无匹配的结果，将返回空指针。
    例如：
strchr ("hello, world", 'l')
     => "llo, world"
strchr ("hello, world", '?')
     => NULL
    表示结束的空字符被认为是字符串的一部分，所以你可以使用这个函数获得指向字符串结尾处的指定（也就是用NULL作参数）。
    函数：char * index (const char *string, int c)
    index是strchr的另一个名字，它们完全一样。
    函数：char * strrchr (const char *string, int c) 
本文的链接为：http://oldsite.linuxaid.com.cn/training/showtri.jsp?i=90
作者为： fjxufeng(风过留枫)
    此函数与strchr类似，区别在于，strchr是从头往后找，而strrchr则是从最后面往前找。例如：
strrchr ("hello, world", 'l')
     => "ld"
    函数：char * rindex (const char *string, int c)
rindex是strrchr的另一个名字，它们完全一样。
    函数：char * strstr (const char *haystack, const char *needle)
    此函数与strchr类似，不同之处是strstr是在字符串haystack中查找子串needle，而不是一个字符。它将返回这个子串所在位置，如果没有找到，将返回空指针。如果needle是一个空字符串，函数将返回haystack。
    例如：
strstr ("hello, world", "l")
    => "llo, world"
strstr ("hello, world", "wo")
    => "world"
    函数：void * memmem (const void *haystack, size_t haystack-len,const void *needle, size_t needle-len)
    此函数与strstr类似，不同之处是字符串needle和haystack都是字符数组，而不是以空字符结束的字符串。Needle-len是字符串needle的长度，haystack-len则是haystack的长度。这个函数是GNU C扩展的。
    函数：size_t strspn (const char *string, const char *skipset)
    函数strcspn（字符串例外范围）用于统计字符串string中包括skipset的最大子串长度，在skipset中的字符顺序无关紧要。例如：
strspn ("hello, world", "abcdefghijklmnopqrstuvwxyz")
     => 5
    函数：size_t strcspn (const char *string, const char *stopset)
    函数strcspn（字符串例外范围）用于统计字符串string中不包括stopset的最大子串长度，例如：
strcspn ("hello, world", "  ,.;!?")
     => 5
    函数：char * strpbrk (const char *string, const char *stopset)
函数strpbrk与strcspn关，它将返回一个指针，指向不包括stopset的子串后第1个字符，如果在字符串string中没找到stopset中的字符，将返回空指针。例如：
strpbrk ("hello, world", "  ,.;!?")
     => ", world"
5.8在字符串中查找
    有时在你的程序中会需要进行一些词法分析、句法分析，例如分解一个命令行。你可以使用strtok函数，这个函数在头文件string.h中声明。
    函数：char * strtok (char *newstring, const char *delimiters)
    可以通过调用strtok函数将一个字符串分成几个部分。
    第一次调用strstok函数时，应该是字符串newstring做为参数。Strtok函数会通过这个调用设置一些状态信息。后面的 strtok函数调用，将以null为参数（newstring），继续进行分解。当遇到一个新的不是null为参数的strstok函数调用，将重新初始化状态信息。库函数保证不会中途影响。
    参数delimiters是用来指定分割不同部分的字符。所有这些字符都将被丢弃。第一个不是delimiters的成员的字符是下一个token的开始，当另一个成员字符被发现，则表示这个token结束。函数返回这个token。
    在下一次调用strtok时，将继续上一次的工作，找下一个token。要注意的是，每个分隔符不一定要是完全相同的，只要属于delimiters就行。
    当字符串newstring被分隔完，或找不到属于delimiter的字符中，strtok将返回一个空指针。
    警告：由于strtok会在分解时修改字符串的值，所以你应该在使用strtok分割时，先将其复制到临时的缓冲区去。如果你让strtok修改了一个程序其它部分的字符串函数，你将会遇到麻烦；因为它们可能还有其他作用。
    如果你操作的字符串是一个常量，而strtok又会试图去修改它，这时程序会导致一个致命错误。
Strtok函数是不可重入的。
以下是一个使用strtok的实例：
#include <string.h>
#include <stddef.h>
...
char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *token;
...
token = strtok (string, delimiters);  /* token => "words" */
token = strtok (NULL, delimiters);    /* token => "separated" */
token = strtok (NULL, delimiters);    /* token => "by" */
token = strtok (NULL, delimiters);    /* token => "spaces" */
token = strtok (NULL, delimiters);    /* token => "and" */
token = strtok (NULL, delimiters);    /* token => "punctuation" */
token = strtok (NULL, delimiters);    /* token => NULL */
GNU C库包括两个可以重入的strtok函数。
    函数：char * strtok_r (char *newstring, const char *delimiters, char **save_ptr)
    就象strtok函数一样，strtok_r函数能够连续调用，以将一个字符串分解成为几个token。不同的时下一个strtok_r函数不会破坏这个函数的状态。因为它提供了一个指向不同函数的**save_ptr指针。
    这个函数是POSIX.1b提出的建议，它被许多系统支持，以提供多线程的字符分解。
    函数：char * strsep (char **string_ptr, const char *delimiter)
    另一个可重入的方法是取消了第一个参数。初始时的指针由用户指定，后面调用的指针则由delimiter决定。返回下一个被分解的token。
    这个函数是在4.3BSD系统中引入的，因此被广泛使用着。
以下是一个使用strsep的实例：
#include <string.h>
#include <stddef.h>
...
char string[] = "words separated by spaces -- and, punctuation!";
const char delimiters[] = " .,;:!-";
char *running;
char *token;
...
running = string;
token = strsep (&running, delimiters);    /* token => "words" */
token = strsep (&running, delimiters);    /* token => "separated" */
token = strsep (&running, delimiters);    /* token => "by" */
token = strsep (&running, delimiters);    /* token => "spaces" */
token = strsep (&running, delimiters);    /* token => "and" */
token = strsep (&running, delimiters);    /* token => "punctuation" */
token = strsep (&running, delimiters);    /* token => NULL */

在很多数据输入的时候,我们需要从文件中输入多个数值,如在给矩阵赋值时,我们需要从文件中读取
1  3  2  4
32  2 10  5
这样一些输入。
那如何能够从文件中快速读取这样一些数值呢？
即我们如何可以从一行字符串中分析出这若干个数值，并进而取值。
我们利用的函数为了strsep函数，这是一个在GNU C中在string.h定义的函数，具体作用为是将一个字符串分成几个部分,其具体实例可见我的Blog中转载的"字符串与数组工具"的文章。
在这里我们只是讲这个函数使用时，值得注意的一些地方。
在使用strsep时，函数会不断地对输入函数按分隔符进行分割，直至返回值为Null为止。
因此，若我们的文件如下所示：
0 1 2
1 2 3
1 2 1
则程序在读取文件中的某一行时，如0 1 2，它首先将0  1  2取出，然后会取到一个NULL值，若不加控制，此NULL值也会输出。此外，由于在Unix的文本文件中，换行时会在每行后加入一个回车符\n，因此我们看到的文件实际在文件中应该是这样表示的：
0 1 2\n
1 2 3\n
1 2 1\n
而由于我们的分隔符为空格，因此可见在取第一行时，我们最后取到的2实际为2\n，因此为了解决这一问题，我们在写输入文件时，要人为地在每行后加入一个空格，即
0 1 2 \n
1 2 3 \n
1 2 1 \n
这样的话就可以避免这一问题的出现。
因此我的程序段如下：
#include <stdio.h>
#include <string.h>
int main(){
    FILE *fp;
    char str[20],*tmp,*substr="a";
    int t,data[5];
    const char delimiters[]=" ";
    fp = fopen("set.txt","r");               //输入文件为set.txt
    while(fgets(str,20,fp)!=NULL){
        tmp = str;
        while(substr!=NULL){
            substr = strsep(&tmp,delimiters);
            if(*substr=='\n')
            break;
            printf("%s ",substr);
        }
        printf("\n");

    }
    fclose(fp);
    return 0;
}
其输出结果为:
0 1 2
1 2 3
1 2 1

C 语言从 C94 引入多语言支持以后处理中文方便多了。即使不用 wchar_t 也可以获得很多好处，比如增加了 strcoll 这个根据 locale 比较字符串的函数。

简单地说，一个 locale 就是一组处理跟语言相关问题的规则，这里有一篇简介。这些规则就包括如何对字符串进行比较和排序。按照 C94 及 C99 标准的规定，程序在启动时设置 locale 为 "C"。在 "C" locale 下，字符串的比较就是按照内码一个字节一个字节地进行，这时 strcoll 与 strcmp 函数没有区别。在其他 locale 下，字符串的比较方式则不同了，例如在简体中文 locale 下，strcmp 仍然按内码比较，而 strcoll 对于汉字则是按拼音进行的（这也跟操作系统有关，Windows 还支持按笔划排序，可以在“区域和语言设置”里面修改）。

在 C 语言里面，用 setlocale 函数设置当前 locale，在程序开头使用一句 setlocale (LC_ALL, ""); 就可以了。第二个参数为空串表示依照操作系统的当前设置。下面是一个示例程序（须使用 C 编译器；如果要用 C++ 编译器，还要自己封装一下 strcoll 或者加一个强制类型转换）：
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <locale.h>

int main (void)
{
    int i;
    char str[10][4]= {"镕","堃","趙","錢","孫","李","周","吳","鄭","王"};
    qsort (str, 10, 4, strcoll);
    printf ("按内码排序：");
    for (i=0; i<10; i++)
        printf ("%s", str[i]);
    setlocale (LC_ALL, "");
    qsort (str, 10, 4, strcoll);
    printf ("\n按音序排序：");
    for (i=0; i<10; i++)
        printf ("%s", str[i]);
    return 0;
}

程序输出（操作系统 GNU/Linux，locale 为 "zh_CN.UTF-8"）：
按内码排序：吳周堃孫李王趙鄭錢镕
按音序排序：堃李錢镕孫王吳趙鄭周

程序输出（操作系统 Windows, locale 为 "Chinese_People's Republic of China.936"）：
按内码排序：吳堃孫李王周趙鄭錢镕
按音序排序：堃李錢镕孫王吳趙鄭周

按内码排序的差别是因为两个测试里使用了不同的内码，但可以看出第二行的结果相同。之所以用了生僻字和繁体字为例，是因为一级汉字在 GB2312 里面恰好是按拼音排的，体现不出差别了。

另外，使用宽字符（wchar_t）的程序在开头一定要使用 setlocale，不然会遇到很多麻烦，比如 wprintf 不能输出中文……

文章出处：http://www.diybl.com/course/3_program/c++/cppsl/20081117/151299.html

一、预备知识—程序的内存分配

由C/C++编译的程序占用的内存分为以下几个部分
1、栈区(stack)： 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区(heap)： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。
3、全局区(static)： 全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域，程序结束后有系统释放 。
4、文字常量区： 常量字符串就是放在这里的， 程序结束后由系统释放。
5、程序代码区： 存放函数体的二进制代码。

Example:

int a = 0; // 全局初始化区
char *p1; // 全局未初始化区
main()
{
int b; // 栈
char s[] = "abc"; // 栈
char *p2; // 栈
char *p3 = "123456"; // 123456\0在常量区，p3在栈上。
static int c =0； // 全局(静态)初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20); // 分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); // 123456\0放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}

二、堆和栈的理论知识

2.1 申请方式
栈: 由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
堆: 需要程序员自己申请，并指明大小，在c中malloc函数：如p1 = (char *)malloc(10); 在C++中用new运算符 如p2 = (char *)malloc(10); 但是注意p1、p2本身是在栈中的。

2.2 申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时， 会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块 内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的 大小，系统会自动的将多余的那部分重新放入空闲链表中。

2.3 申请大小的限制
栈：在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在 WINDOWS下，栈的大小是2M(也有的说是1M，总之是一个编译时就确定的常数)，如果申请的空间超过栈的剩余空间时，将提示overflow。因 此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

2.4 申请效率的比较：
栈：由系统自动分配，速度较快。但程序员是无法控制的。
堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

2.5 堆和栈中的存储内容
栈： 在函数调用时，第一个进栈的是主函数中后的下一条指令(函数调用语句的下一条可执行语句)的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由 右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址， 也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。

2.6 存取效率的比较
char s1[] = "aaaaaaaaaaaaaaa";
char *s2 = "bbbbbbbbbbbbbbbbb";
aaaaaaaaaaa是在运行时刻赋值的；
而bbbbbbbbbbb是在编译时就确定的；
但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。
比如：
#include
void main()
{
char a = 1;
char c[] = "1234567890";
char *p ="1234567890";
a = c[1];
a = p[1];
return;
}
对应的汇编代码
10: a = c[1];
00401067 8A 4D F1 mov cl,byte ptr [ebp-0Fh]
0040106A 88 4D FC mov byte ptr [ebp-4],cl
11: a = p[1];
0040106D 8B 55 EC mov edx,dword ptr [ebp-14h]
00401070 8A 42 01 mov al,byte ptr [edx+1]
00401073 88 45 FC mov byte ptr [ebp-4],al
第一种在读取时直接就把字符串中的元素读到寄存器cl中，而第二种则要先把指针值读到edx中，在根据edx读取字符，显然慢了。

2.7 小结：
堆和栈的区别可以用如下的比喻来看出： 使用栈就象我们去饭馆里吃饭，只管点菜(发出申请)、付钱、和吃(使用)，吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是 快捷，但是自由度小。 使用堆就象是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。

还有就是函数调用时会在栈上有一系列的保留现场及传递参数的操作。栈的空间大小有限定，VC的缺省是2M。栈不够用的情况一般是程序中分配了大量 数组和递归函数层次太深。有一点必须知道，当一个函数调用完返回后它会释放该函数中所有的栈空间。栈是由编译器自动管理的，不用你操心。堆是动态分配内存 的，并且你可以分配使用很大的内存。但是用不好会产生内存泄漏。并且频繁地malloc和free会产生内存碎片(有点类似磁盘碎片)，因为C分配动态内 存时是寻找匹配的内存的。而用栈则不会产生碎片。在栈上存取数据比通过指针在堆上存取数据快些。一般大家说的堆栈和栈是一样的，就是栈(stack)，而 说堆时才是堆heap。栈是先入后出的，一般是由高地址向低地址生长。
文章出处：http://www.diybl.com/course/3_program/c/c_js/2007109/77275.html

原型：extern char *strstr(char *haystack, char *needle);
所在头文件：#include <string.h>
功能：从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)。
说明：返回指向第一次出现needle位置的指针，如果没找到则返回NULL。

具体使用例子：

原型：char *strtok(char *s, char *delim);
功能：分解字符串为一组字符串。s为要分解的字符串，delim为分隔符字符串。实质上的处理是，strtok在s中查找包含在delim中的字符并用NULL(’\0′)来替换,直到找遍整个字符串。
说明：首次调用时，s指向要分解的字符串，之后再次调用要把s设成NULL。strtok在s中查找包含在delim中的字符并用NULL(’\0′)来替换，直到找遍整个字符串。
返回值：从s开头开始的一个个被分割的串。当没有被分割的串时则返回NULL。所有delim中包含的字符都会被滤掉，并将被滤掉的地方设为一处分割的节点。

具体使用例子：

●利用StringTokenizer类：

Java中的字符串也是一连串的字符。但是与许多其他的计算机语言将字符串作为字符数组处理不同，Java将字符串作为String类型对象来处理。将字 符串作为内置的对象处理允许Java提供十分丰富的功能特性以方便处理字符串。下面是一些使用频率比较高的函数及其相关说明。

substring()
它有两种形式，第一种是：String substring(int startIndex)
第二种是：String substring(int startIndex,int endIndex)

concat() 连接两个字符串

replace() 替换
它有两种形式，第一种形式用一个字符在调用字符串中所有出现某个字符的地方进行替换，形式如下：
String replace(char original,char replacement)
例如：String s=”Hello”.replace(’l',’w');
第二种形式是用一个字符序列替换另一个字符序列，形式如下：
String replace(CharSequence original,CharSequence replacement)

trim() 去掉起始和结尾的空格

valueOf() 转换为字符串

toLowerCase() 转换为小写

toUpperCase() 转换为大写

length() 取得字符串的长度
例：
char chars[]={’a',’b’.’c'};
String s=new String(chars);
int len=s.length();

charAt() 截取一个字符
例：
char ch;
ch=”abc”.charAt(1);
返回值为’b’

getChars() 截取多个字符
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)
sourceStart 指定了子串开始字符的下标
sourceEnd 指定了子串结束后的下一个字符的下标。因此，子串包含从sourceStart到sourceEnd-1的字符。
target 指定接收字符的数组
targetStart target中开始复制子串的下标值
例：
String s=”this is a demo of the getChars method.”;
char buf[]=new char[20];
s.getChars(10,14,buf,0);

getBytes()
替代getChars()的一种方法是将字符存储在字节数组中，该方法即getBytes()
例：
String s = “Hello!你好！”;
byte[] bytes = s.getBytes();

toCharArray()
例：
String s = “Hello!你好！”;
char[] ss = s.toCharArray();

equals()和equalsIgnoreCase() 比较两个字符串

regionMatches() 用于比较一个字符串中特定区域与另一特定区域，它有一个重载的形式允许在比较中忽略大小写。
boolean regionMatches(int startIndex,String str2,int
str2StartIndex,int numChars)
boolean regionMatches(boolean ignoreCase,int startIndex,String
str2,int str2StartIndex,int numChars)

startsWith()和endsWith()
startsWith()方法决定是否以特定字符串开始，endWith()方法决定是否以特定字符串结束

equals()和==
equals()方法比较字符串对象中的字符，==运算符比较两个对象是否引用同一实例。
例：String s1=”Hello”;
String s2=new String(s1);
s1.eauals(s2); //true
s1==s2;//false

compareTo()和compareToIgnoreCase() 比较字符串

indexOf()和lastIndexOf()
indexOf() 查找字符或者子串第一次出现的地方。
lastIndexOf() 查找字符或者子串是后一次出现的地方。

StringBuffer构造函数
StringBuffer定义了三个构造函数：
StringBuffer()
StringBuffer(int size)
StringBuffer(String str)
StringBuffer(CharSequence chars)

下面是StringBuffer相关的函数：
length()和capacity()
一个StringBuffer当前长度可通过length()方法得到,而整个可分配空间通过capacity()方法得到。

ensureCapacity() 设置缓冲区的大小
void ensureCapacity(int capacity)

setLength() 设置缓冲区的长度
void setLength(int len)

charAt()和setCharAt()
char charAt(int where)
void setCharAt(int where,char ch)

getChars()
void getChars(int sourceStart,int sourceEnd,char target[],int targetStart)

append() 可把任何类型数据的字符串表示连接到调用的StringBuffer对象的末尾。
例：int a=42;
StringBuffer sb=new StringBuffer(40);
String s=sb.append(”a=”).append(a).append(”!”).toString();

insert() 插入字符串
StringBuffer insert(int index,String str)
StringBuffer insert(int index,char ch)
StringBuffer insert(int index,Object obj)
index指定将字符串插入到StringBuffer对象中的位置的下标。

reverse() 颠倒StringBuffer对象中的字符
StringBuffer reverse()

delete()和deleteCharAt() 删除字符
StringBuffer delete(int startIndex,int endIndex)
StringBuffer deleteCharAt(int loc)

replace() 替换
StringBuffer replace(int startIndex,int endIndex,String str)

substring() 截取子串
String substring(int startIndex)
String substring(int startIndex,int endIndex)

28年前，一封名为《人生的路为什么越走越窄》的读者来信见报后，曾在全国青年人中引发了一场关于理想和现实的大讨论。
28年后，一个24岁的来自底层的打工青年再次被逼至墙角——当理想被沉重的现实不断围剿，直到成为他生命中不能承受之重。他最后选择了在人间蒸发，成为他亲人的长久牵挂。
这个喜欢庄子的80后叫罗炼，他的故事受到了湖南卫视《零点锋云》栏目的关注，节目播出后迅速成为社会热议的一个话题。当栏目制作方邀我为这个年轻人写点什么的时候，我毫不犹豫地答应了——只为一个今天太多人认为很装很虚无的东西——理想。
在这个充斥着娱乐致死加功利主义盛行的时代，罗炼的故事显得遗世独立，对太多人进行了一次真切的逼问：现实充满诱惑更充满严酷的挑战，你还会仰望理想的星空吗？您将凭借什么坚持到底？
有志青年罗炼怀揣着纸一般脆弱的文学梦，怀揣着家人殷殷的期待离开乡村，来到南下广东打工，先后辗转于珠江三角洲，做过保安、油漆工，跑过太阳能和房地产生意，开始了理想与现实的残酷PK。罗炼面对的是一个日益繁荣的商业世界，每天都在激发他的进取心和创业成功的渴望。整整六年，他是那样努力，但成功依旧那么遥远。终于,由于生存压力如影随形的逼迫，理想还未展翅翱翔，便已支离破碎，宛如断线的纸鸢。
逐步走向时代舞台中心的80后，是一群幸运儿。因为他们有着更完美的物质环境、更开阔的眼界、更充盈的知识、更独立的个性。但他们又是不幸的。这些家庭的宠儿（绝大多数是独生子女）往往都从小缺乏苦难和挫折的锤炼，一上路便极易受现实急功近利思潮熏陶，往往追求速成，忽略对现实的适应能力的培养、自身能力的提升和社会经验的累积，一旦遭遇社会充分竞争带来的巨大压力以及阶层分化带来的各种机会不公，便要么迅速麻木，甚至蜕变成及时行乐的猪；要么悲观厌世，选择逃避，如同罗炼。
从这个意义上，整个80后乃至更多理想主义者在和罗炼一起流浪。他们往往胸怀大志，却总是慨叹报国无门。我首先还是为他们的坚持致敬，因为按照人正常发展的规律，你如果放弃了理想，那你下一步一定会尝试放弃良心。
年轻的罗炼们其实无处逃遁，因为世间已无“不知有汉，无论魏晋”的桃花源。
我想起一个这样的故事。伊斯兰教创始人默罕莫德带领大军进行圣战的途中,遇到一座险峻高山，士兵望而生畏，默罕莫德说：我念一个咒语，真主就会让山自动移开。谁料念罢山岿然不动，于是，默罕莫德说：既然山不走向我们，就让我们走向山吧。
要想坚持并实现理想，首先要学会承认现实。因为这是你无法改变和逃避的。要学会“头顶理想的天空，脚踩现实的大地。”这个世界从来都不完美，也充满不公，但改变这一切不正是我们存在的理由吗？
其次，要明白任何一个理想的实现都不是由于一个伟大的想法，而是因为一个伟大的方法。这需要经验、阅历甚至学识的积累和百折不回的探索——“有何胜利而言，挺住意味着一切！”
最后，也是最重要的是内心的修炼，比行动上不抛弃、不放弃更关键的是不抱怨。塞林格在《麦天里的守望者》写下这么一句充满智慧的话：一个男人不成熟的标志在于他甘愿为某个事业英勇地献身，一个男人成熟的标志在于他甘愿为某个事业卑贱地活着。
出身寒微但心比天高的罗炼像个受伤的孩子。他的理想在天上，可惜他的通天塔需要从现实的最底层一砖一瓦地建立。太年轻的他无法忍受这样漫长的等待和付出，于是，他当了逃兵。
我想告诉他这样一句话：我们到遥远的地方去寻找，青鸟却在我们的出发之地。

背景
24岁的罗炼来自湖南省浏阳市沙市镇，高中文化，是一个喜欢读庄子的年轻人，系文学青年。5年前，带着梦想南下广东打工，先后辗转于珠江三角洲，做过保安、油漆工，跑过太阳能和房地产生意。2008年9月14日中秋节，在家具厂做学徒的他在月饼盒里，留下一纸手写字条后，悄然出走，至今不知所终。他在字条里写道：“终生役役而不见成功，苶(nie)然疲役而不知所向，讳穷不免，求通不得，无以树业，无以养亲，不亦悲乎！人谓之不死，奚益！”

       当发生IRQ异常CPU跳转至异常向量表0x00000018处执行指令LDR PC,[PC,#-0x0FF0]，此时程序计数器PC中内容应该为0x00000020，CPU执行完成该指令将地址 【0x00000020-0x0ff0=】0xFFFFF030(VICVectAddr)装入PC，程序转入IRQ异常处理例程。