實務上兩個星星**(*)算是最多了，有看過三個星星的使用嗎?
因為C語言的特性，字串陣列是二維的陣列，所以char *str[]算常用吧，
這時用char **str**，反而不易看出字串陣列，
我猜作者大概是這個用意吧?!!所以範例程式不太用char **str。
也是可讀性的一種體現。
其他語言，有字串型別，字串陣列應該是一維陣列吧。

本書第三個qsort的版本，高級版(標準版?)
作者試著要process any data type, not just character strings.
第一個範例，處理數字，第二個範例處理字串陣列，
這個範例試圖要一起處理。
第三版原型如下:
void qsort(**void ***v[], int left, int right,
int (*comp)(void *, void *))

最引人注意的是void的使用。
第一個沒有帶星號的void, 表示沒有return值。
其他的帶星號的void，

The generic pointer type void * is used for the pointer arguments. Any pointer can be cast to void * and back
again without loss of information,

泛型(generic )指標型別void *，用來做指標的參數，任何指標可轉型(cast )
成void *，且回復型別時不會遺失任何資訊。
*!@#，這段話，筆者不知道要怎麼驗証，算是定義(無需証明)，還是定理(可以証明)呢?
因為要能夠處理各種型別，不給定某特定型別，所以就產生了void *用於這種特定用途。
所以void 和void *，共用void這個字，其意義是天差地遠。

int (*comp)(void *, void *)

which says that comp is a pointer to a function that has two void * arguments and returns an int
意思是說，comp 是指向函數的指標，這個函數(不指定名稱)是有2個void *參數，傳回整數的
原型。如果沒有看書，用舊有經驗來理解程式，所謂用除錯器來學習程式的人，幾乎沒辦法完整理解這段宣告。
也許理解成:一個名為comp函數，傳回指向int的指標，這個comp函數，有兩個void *參數，，沒有函數指標的概念時，會這樣理解，但不懂為什麼它這樣寫，就可以切換
strcmp，numcmp。一切是配套的。
原作者即使是這個小節，也2~3頁就帶過，所以本書雖精簡。

不禁回想作者在評論UNIX系統的設計，UNIX是簡單的系統，透過天才的眼光來看的話。

UNIX 的KISS (Keep It Simple, Stupid)哲學，雖然貫穿整個系統，在看穿簡單的本質之前，應該也曾經把事情搞得很複雜過，才會找出簡單的本質。
第三版的code，特別排版後，放上來，之前真得誤以為程式碼功能會變色，還會自動縮排。原來是誤判!!

#include <stdio.h>
#include <string.h>
#define MAXLINES 5000 /* max #lines to be sorted */
char *lineptr[MAXLINES]; /* pointers to text lines */
int readlines(char *lineptr[], int nlines);
void writelines(char *lineptr[], int nlines);
void qsort(void *lineptr[], int left, int right,
	   int (*comp)(void *, void *));
int numcmp(char *, char *);
int strcmp(char *, char *);
/* sort input lines */
main(int argc, char *argv[])
{
  int nlines; /* number of input lines read */
  int numeric = 0; /* 1 if numeric sort */
  if (argc > 1 && strcmp(argv[1], "-n") == 0)
    numeric = 1;
  if ((nlines = readlines(lineptr, MAXLINES)) >= 0) 
    {
      qsort((void**) lineptr, 0, nlines-1,
	    (int (*)(void*,void*))(numeric ? numcmp : strcmp));
      writelines(lineptr, nlines);
      return 0;
    } 
  else
    {
      printf("input too big to sort\n");
      return 1;
    }
}
  void swap(void *v[], int, int);
/* qsort: sort v[left]...v[right] into increasing order */
void qsort(void *v[], int left, int right,
	   int (*comp)(void *, void *))
{
  int i, last;

  if (left >= right) /* do nothing if array contains */
    return; /* fewer than two elements */
  swap(v, left, (left + right)/2);
  last = left;
  for (i = left+1; i <= right; i++)
    if ((*comp)(v[i], v[left]) < 0)
      swap(v, ++last, i);
  swap(v, left, last);
  qsort(v, left, last-1, comp);
  qsort(v, last+1, right, comp);
}
/* strcmp: return <0 if s<t, 0 if s==t, >0 if s>t */
int strcmp(char *s, char *t)
{
  for ( ; *s == *t; s++, t++)
    if (*s == '\0')
      return 0;
  return *s - *t;
}

/* numcmp: compare s1 and s2 numerically */
int numcmp(char *s1, char *s2)
{
  double v1, v2;
  v1 = atof(s1);
  v2 = atof(s2);
  if (v1 < v2)
    return -1;
  else if (v1 > v2)
    return 1;
  else
    return 0;
}

#define MAXLEN 1000 /* max length of any input line */
char *alloc(int);
/* readlines: read input lines */
int readlines(char **lineptr, int maxlines)
{
  int len, nlines;
  char *p, line[MAXLEN];
  nlines = 0;
  while ((len = getline(line, MAXLEN)) > 0)
    if (nlines >= maxlines || (p = alloc(len)) == NULL)
      return -1;
    else 
      {
	line[len-1] = '\0'; /* delete newline */
	strcpy(p, line);
	*(lineptr+nlines++)= p;
      }
  return nlines;
}

int getline(char *s,int lim)  //s[]->*s
{
  int c, i;
  for (i=0; i < lim-1 && (c=getchar())!=EOF && c!='\n'; ++i)
    *(s+i) = c; //s[i]

  if (c == '\n')
    {
      *(s+i) = c; // s[i]
      ++i;
    }
  *(s+i) = '\0'; //s[i]
  return i;
}
/* writelines: write output lines */
void writelines(char **lineptr, int nlines)
{
  int i;
  for (i = 0; i < nlines; i++)
    printf("%s\n", *(lineptr+i));
}

/* swap: interchange v[i] and v[j] */
void swap(char **v, int i, int j)
{
  char *temp;
  temp = *(v+i);
  *(v+i) = *(v+j);
  *(v+j) = temp;
}

#define ALLOCSIZE 10000 /* size of available space */
static char allocbuf[ALLOCSIZE]; /* storage for alloc */
static char *allocp = allocbuf; /* next free position */
char *alloc(int n) /* return pointer to n characters */
{
  if (allocbuf + ALLOCSIZE - allocp >= n)
    { /* it fits */
    allocp += n;
    return allocp - n; /* old p */
    }
  else /* not enough room */
    return 0;
}

筆者終於原著的原汁原味，故意把**#include <string.h>**註解掉，
用書中的strcmp函數，不解，為何作者不用自己編的呢?
如果沒註解掉，會產生

sort04.c:10:5: error: conflicting types for 'strcmp'
sort04.c:50:5: error: conflicting types for 'strcmp'

註解掉，
卻產生

sort04.c: In function 'readlines':
sort04.c:97:2: warning: incompatible implicit declaration of built-in function 'strcpy'

一個產生error，一個產生warning，值得再探討的小問題。

不知道是不是這個緣故，
執行結果，並不如預期，
字串陣列的排序符合預期，數字陣列的排序不符合。

$ a
You
Give
Love
A
Bad
Name
^Z
A
Bad
Give
Love
Name
You

加上 -n的參數

$ a -n
You
Give
Love
A
Bad
Name
^Z
Love
A
Give
Bad
You
Name

所以 -n 照題意是排序數字陣列，
目前效果是

$ a -n
88
77
66
55
44
33
22
11
^Z
55
44
77
33
88
22
66
11

莫非筆者找到了bug??

今天事忙，改天再深究了。