C语言接口与实现[+]

最新推荐文章于 2024-09-20 10:13:53 发布
最新推荐文章于 2024-09-20 10:13:53 发布
阅读量3k 收藏 7
点赞数 1
分类专栏： Linux C 常用算法汇总
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/benpaobagzb/article/details/48441909
版权
该博客详细介绍了C语言中接口与实现的紧密关系，通过Arith接口、抽象数据类型Stack、原子、异常处理、内存管理等关键概念的实例解析，深入探讨了C语言编程中的核心要素。从原子接口到高级数据结构如链表、表格和集合，展示了C语言在构建高效程序中的应用。
摘要由CSDN通过智能技术生成

第1章 简介

1. literate程序

2. 宏指令与条件编译指令

第2章 接口与实现

1. 接口与实现的关系

2. Arith接口及实现：

arith.h:

复制代码
/*  $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $  */
extern  int Arith_max( int x,  int y);
extern  int Arith_min( int x,  int y);
extern  int Arith_div( int x,  int y);
extern  int Arith_mod( int x,  int y);
extern  int Arith_ceiling( int x,  int y);
extern  int Arith_floor  ( int x,  int y);
复制代码

arith.c

 

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $ ";
#include  " arith.h "
int Arith_max( int x,  int y) {
     return x > y ? x : y;
}
int Arith_min( int x,  int y) {
     return x > y ? y : x;
}
int Arith_div( int x,  int y) {
     if (- 13/ 5 == - 2
    &&    (x <  0) != (y <  0) && x%y !=  0)
         return x/y -  1;
     else
         return x/y;
}
int Arith_mod( int x,  int y) {
     if (- 13/ 5 == - 2
    &&    (x <  0) != (y <  0) && x%y !=  0)
         return x%y + y;
     else
         return x%y;
}
int Arith_floor( int x,  int y) {
     return Arith_div(x, y);
}
int Arith_ceiling( int x,  int y) {
     return Arith_div(x, y) + (x%y !=  0);
}
复制代码

 

3. 抽象数据类型Stack

4. 客户调用程序的责任

stack.h

View Code

stack.c 

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/inter.doc,v 1.11 1997/02/21 19:42:15 drh Exp $ ";
#include <stddef.h>
#include  " assert.h "
#include  " mem.h "
#include  " stack.h "
#define T Stack_T
struct T {
     int count;
     struct elem {
         void *x;
         struct elem *link;
    } *head;
};
T Stack_new( void) {
    T stk;
    NEW(stk);
    stk->count =  0;
    stk->head = NULL;
     return stk;
}
int Stack_empty(T stk) {
    assert(stk);
     return stk->count ==  0;
}
void Stack_push(T stk,  void *x) {
     struct elem *t;
    assert(stk);
    NEW(t);
    t->x = x;
    t->link = stk->head;
    stk->head = t;
    stk->count++;
}
void *Stack_pop(T stk) {
     void *x;
     struct elem *t;
    assert(stk);
    assert(stk->count >  0);
    t = stk->head;
    stk->head = t->link;
    stk->count--;
    x = t->x;
    FREE(t);
     return x;
}
void Stack_free(T *stk) {
     struct elem *t, *u;
    assert(stk && *stk);
     for (t = (*stk)->head; t; t = u) {
        u = t->link;
        FREE(t);
    }
    FREE(*stk);
}
复制代码

第3章 原子

1. 接口

atom.h: 

View Code

atom.c:

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/atom.doc,v 1.10 1997/02/21 19:42:46 drh Exp $ ";
#include  " atom.h "
#include < string.h>
#include  " assert.h "
#include <limits.h>
#include  " mem.h "
#define NELEMS(x) ((sizeof (x))/(sizeof ((x)[0])))
static  struct atom {
     struct atom *link;
     int len;
     char *str;
} *buckets[ 2048];
static unsigned  long scatter[] = {
2078917053,  143302914,  1027100827,  1953210302,  755253631,  2002600785,
1405390230,  45248011,  1099951567,  433832350,  2018585307,  438263339,
813528929,  1703199216,  618906479,  573714703,  766270699,  275680090,
1510320440,  1583583926,  1723401032,  1965443329,  1098183682,  1636505764,
980071615,  1011597961,  643279273,  1315461275,  157584038,  1069844923,
471560540,  89017443,  1213147837,  1498661368,  2042227746,  1968401469,
1353778505,  1300134328,  2013649480,  306246424,  1733966678,  1884751139,
744509763,  400011959,  1440466707,  1363416242,  973726663,  59253759,
1639096332,  336563455,  1642837685,  1215013716,  154523136,  593537720,
704035832,  1134594751,  1605135681,  1347315106,  302572379,  1762719719,
269676381,  774132919,  1851737163,  1482824219,  125310639,  1746481261,
1303742040,  1479089144,  899131941,  1169907872,  1785335569,  485614972,
907175364,  382361684,  885626931,  200158423,  1745777927,  1859353594,
259412182,  1237390611,  48433401,  1902249868,  304920680,  202956538,
348303940,  1008956512,  1337551289,  1953439621,  208787970,  1640123668,
1568675693,  478464352,  266772940,  1272929208,  1961288571,  392083579,
871926821,  1117546963,  1871172724,  1771058762,  139971187,  1509024645,
109190086,  1047146551,  1891386329,  994817018,  1247304975,  1489680608,
706686964,  1506717157,  579587572,  755120366,  1261483377,  884508252,
958076904,  1609787317,  1893464764,  148144545,  1415743291,  2102252735,
1788268214,  836935336,  433233439,  2055041154,  2109864544,  247038362,
299641085,  834307717,  1364585325,  23330161,  457882831,  1504556512,
1532354806,  567072918,  404219416,  1276257488,  1561889936,  1651524391,
618454448,  121093252,  1010757900,  1198042020,  876213618,  124757630,
2082550272,  1834290522,  1734544947,  1828531389,  1982435068,  1002804590,
1783300476,  1623219634,  1839739926,  69050267,  1530777140,  1802120822,
316088629,  1830418225,  488944891,  1680673954,  1853748387,  946827723,
1037746818,  1238619545,  1513900641,  1441966234,  367393385,  928306929,
946006977,  985847834,  1049400181,  1956764878,  36406206,  1925613800,
2081522508,  2118956479,  1612420674,  1668583807,  1800004220,  1447372094,
523904750,  1435821048,  923108080,  216161028,  1504871315,  306401572,
2018281851,  1820959944,  2136819798,  359743094,  1354150250,  1843084537,
1306570817,  244413420,  934220434,  672987810,  1686379655,  1301613820,
1601294739,  484902984,  139978006,  503211273,  294184214,  176384212,
281341425,  228223074,  147857043,  1893762099,  1896806882,  1947861263,
1193650546,  273227984,  1236198663,  2116758626,  489389012,  593586330,
275676551,  360187215,  267062626,  265012701,  719930310,  1621212876,
2108097238,  2026501127,  1865626297,  894834024,  552005290,  1404522304,
48964196,  5816381,  1889425288,  188942202,  509027654,  36125855,
365326415,  790369079,  264348929,  513183458,  536647531,  13672163,
313561074,  1730298077,  286900147,  1549759737,  1699573055,  776289160,
2143346068,  1975249606,  1136476375,  262925046,  92778659,  1856406685,
1884137923,  53392249,  1735424165,  1602280572
};
const  char *Atom_string( const  char *str) {
    assert(str);
     return Atom_new(str, strlen(str));
}
const  char *Atom_int( long n) {
     char str[ 43];
     char *s = str +  sizeof str;
    unsigned  long m;
     if (n == LONG_MIN)
        m = LONG_MAX +  1UL;
     else  if (n <  0)
        m = -n;
     else
        m = n;
     do
        *--s = m% 10 +  ' 0 ';
     while ((m /=  10) >  0);
     if (n <  0)
        *--s =  ' - ';
     return Atom_new(s, (str +  sizeof str) - s);
}
const  char *Atom_new( const  char *str,  int len) {
    unsigned  long h;
     int i;
     struct atom *p;
    assert(str);
    assert(len >=  0);
     for (h =  0, i =  0; i < len; i++)
        h = (h<< 1) + scatter[(unsigned  char)str[i]];
    h &= NELEMS(buckets)- 1;
     for (p = buckets[h]; p; p = p->link)
         if (len == p->len) {
             for (i =  0; i < len && p->str[i] == str[i]; )
                i++;
             if (i == len)
                 return p->str;
        }
    p = ALLOC( sizeof (*p) + len +  1);
    p->len = len;
    p->str = ( char *)(p +  1);
     if (len >  0)
        memcpy(p->str, str, len);
    p->str[len] =  ' \0 ';
    p->link = buckets[h];
    buckets[h] = p;
     return p->str;
}
int Atom_length( const  char *str) {
     struct atom *p;
     int i;
    assert(str);
     for (i =  0; i < NELEMS(buckets); i++)
         for (p = buckets[i]; p; p = p->link)
             if (p->str == str)
                 return p->len;
    assert( 0);
     return  0;
}
复制代码

第4章 异常与断言

except.h 

复制代码
/*  $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $  */
#ifndef EXCEPT_INCLUDED
#define EXCEPT_INCLUDED
#include <setjmp.h>
#define T Except_T
typedef  struct T {
     char *reason;
} T;
typedef  struct Except_Frame Except_Frame;
struct Except_Frame {
    Except_Frame *prev;
    jmp_buf env;
     const  char *file;
     int line;
     const T *exception;
};
enum { Except_entered= 0, Except_raised,
       Except_handled,   Except_finalized };
#ifdef WIN32
__declspec(thread)
#endif
extern Except_Frame *Except_stack;
extern  const Except_T Assert_Failed;
void Except_raise( const T *e,  const  char *file, int line);
#define RAISE(e) Except_raise(&(e), __FILE__, __LINE__)
#define RERAISE Except_raise(Except_frame.exception, \
    Except_frame.file, Except_frame.line)
#define RETURN switch (Except_stack = Except_stack->prev,0) default: return
#define TRY do { \
     volatile  int Except_flag; \
    Except_Frame Except_frame; \
    Except_frame.prev = Except_stack; \
    Except_stack = &Except_frame;  \
    Except_flag = setjmp(Except_frame.env); \
     if (Except_flag == Except_entered) {
#define EXCEPT(e) \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    }  else  if (Except_frame.exception == &(e)) { \
        Except_flag = Except_handled;
#define ELSE \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    }  else { \
        Except_flag = Except_handled;
#define FINALLY \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
    } { \
         if (Except_flag == Except_entered) \
            Except_flag = Except_finalized;
#define END_TRY \
         if (Except_flag == Except_entered) Except_stack = Except_stack->prev; \
        }  if (Except_flag == Except_raised) RERAISE; \
}  while ( 0)
#undef T
#endif
复制代码

except.c 

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $ ";
#include <stdlib.h>
#include <stdio.h>
#include  " assert.h "
#include  " except.h "
#define T Except_T
#ifdef WIN32
__declspec(thread)
#endif
Except_Frame *Except_stack = NULL;
void Except_raise( const T *e,  const  char *file,
     int line) {
    Except_Frame *p = Except_stack;
    assert(e);
     if (p == NULL) {
        fprintf(stderr,  " Uncaught exception ");
         if (e->reason)
            fprintf(stderr,  "  %s ", e->reason);
         else
            fprintf(stderr,  "  at 0x%p ", e);
         if (file && line >  0)
            fprintf(stderr,  "  raised at %s:%d\n ", file, line);
        fprintf(stderr,  " aborting...\n ");
        fflush(stderr);
        abort();
    }
    p->exception = e;
    p->file = file;
    p->line = line;
    Except_stack = Except_stack->prev;
    longjmp(p->env, Except_raised);
}
复制代码

assert.h

复制代码
/*  $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $  */
#undef assert
#ifdef NDEBUG
#define assert(e) ((void)0)
#else
#include  " except.h "
extern  void assert( int e);
#define assert(e) ((void)((e)||(RAISE(Assert_Failed),0)))
#endif
复制代码

assert.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/except.doc,v 1.10 1997/02/21 19:43:55 drh Exp $ ";
#include  " assert.h "
const Except_T Assert_Failed = {  " Assertion failed " };
void (assert)( int e) {
    assert(e);
}
复制代码

 

第5章 内存管理

MEM分配接口

mem.h

复制代码
/*  $Id: H:/drh/idioms/book/RCS/mem.doc,v 1.12 1997/10/27 23:08:05 drh Exp $  */
#ifndef MEM_INCLUDED
#define MEM_INCLUDED
#include  " except.h "
extern  const Except_T Mem_Failed;
extern  void *Mem_alloc ( long nbytes,
     const  char *file,  int line);
extern  void *Mem_calloc( long count,  long nbytes,
     const  char *file,  int line);
extern  void Mem_free( void *ptr,
     const  char *file,  int line);
extern  void *Mem_resize( void *ptr,  long nbytes,
     const  char *file,  int line);
#define ALLOC(nbytes) \
    Mem_alloc((nbytes), __FILE__, __LINE__)
#define CALLOC(count, nbytes) \
    Mem_calloc((count), (nbytes), __FILE__, __LINE__)
#define  NEW(p) ((p) = ALLOC((long)sizeof *(p)))
#define NEW0(p) ((p) = CALLOC(1, (long)sizeof *(p)))
#define FREE(ptr) ((void)(Mem_free((ptr), \
    __FILE__, __LINE__), (ptr) =  0))
#define RESIZE(ptr, nbytes)     ((ptr) = Mem_resize((ptr), \
    (nbytes), __FILE__, __LINE__))
#endif
复制代码

 

 

mem.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/mem.doc,v 1.12 1997/10/27 23:08:05 drh Exp $ ";
#include <stdlib.h>
#include <stddef.h>
#include  " assert.h "
#include  " except.h "
#include  " mem.h "
const Except_T Mem_Failed = {  " Allocation Failed " };
void *Mem_alloc( long nbytes,  const  char *file,  int line){
     void *ptr;
    assert(nbytes >  0);
    ptr = malloc(nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}
void *Mem_calloc( long count,  long nbytes,
     const  char *file,  int line) {
     void *ptr;
    assert(count >  0);
    assert(nbytes >  0);
    ptr = calloc(count, nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}
void Mem_free( void *ptr,  const  char *file,  int line) {
     if (ptr)
        free(ptr);
}
void *Mem_resize( void *ptr,  long nbytes,
     const  char *file,  int line) {
    assert(ptr);
    assert(nbytes >  0);
    ptr = realloc(ptr, nbytes);
     if (ptr == NULL)
        {
             if (file == NULL)
                RAISE(Mem_Failed);
             else
                Except_raise(&Mem_Failed, file, line);
        }
     return ptr;
}
复制代码

 

第6章 进一步内存管理

arena.h

View Code

 

arena.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/arena.doc,v 1.10 1997/02/21 19:45:19 drh Exp $ ";
#include <stdlib.h>
#include < string.h>
#include  " assert.h "
#include  " except.h "
#include  " arena.h "
#define T Arena_T
const Except_T Arena_NewFailed =
    {  " Arena Creation Failed " };
const Except_T Arena_Failed    =
    {  " Arena Allocation Failed " };
#define THRESHOLD 10
struct T {
    T prev;
     char *avail;
     char *limit;
};
union align {
#ifdef MAXALIGN
     char pad[MAXALIGN];
#else
     int i;
     long l;
     long *lp;
     void *p;
     void (*fp)( void);
     float f;
     double d;
     long  double ld;
#endif
};
union header {
     struct T b;
    union align a;
};
static T freechunks;
static  int nfree;
T Arena_new( void) {
    T arena = malloc( sizeof (*arena));
     if (arena == NULL)
        RAISE(Arena_NewFailed);
    arena->prev = NULL;
    arena->limit = arena->avail = NULL;
     return arena;
}
void Arena_dispose(T *ap) {
    assert(ap && *ap);
    Arena_free(*ap);
    free(*ap);
    *ap = NULL;
}
void *Arena_alloc(T arena,  long nbytes,
     const  char *file,  int line) {
    assert(arena);
    assert(nbytes >  0);
    nbytes = ((nbytes +  sizeof (union align) -  1)/
        ( sizeof (union align)))*( sizeof (union align));
     while (nbytes > arena->limit - arena->avail) {
        T ptr;
         char *limit;
         if ((ptr = freechunks) != NULL) {
            freechunks = freechunks->prev;
            nfree--;
            limit = ptr->limit;
        }  else {
             long m =  sizeof (union header) + nbytes +  10* 1024;
            ptr = malloc(m);
             if (ptr == NULL)
                {
                     if (file == NULL)
                        RAISE(Arena_Failed);
                     else
                        Except_raise(&Arena_Failed, file, line);
                }
            limit = ( char *)ptr + m;
        }
        *ptr = *arena;
        arena->avail = ( char *)((union header *)ptr +  1);
        arena->limit = limit;
        arena->prev  = ptr;
    }
    arena->avail += nbytes;
     return arena->avail - nbytes;
}
void *Arena_calloc(T arena,  long count,  long nbytes,
     const  char *file,  int line) {
     void *ptr;
    assert(count >  0);
    ptr = Arena_alloc(arena, count*nbytes, file, line);
    memset(ptr,  ' \0 ', count*nbytes);
     return ptr;
}
void Arena_free(T arena) {
    assert(arena);
     while (arena->prev) {
         struct T tmp = *arena->prev;
         if (nfree < THRESHOLD) {
            arena->prev->prev = freechunks;
            freechunks = arena->prev;
            nfree++;
            freechunks->limit = arena->limit;
        }  else
            free(arena->prev);
        *arena = tmp;
    }
    assert(arena->limit == NULL);
    assert(arena->avail == NULL);
}
复制代码

 

第7章 链表

 

list.h

复制代码
/*  $Id: H:/drh/idioms/book/RCS/list.doc,v 1.11 1997/02/21 19:46:01 drh Exp $  */
#ifndef LIST_INCLUDED
#define LIST_INCLUDED
#define T List_T
typedef  struct T *T;
struct T {
    T rest;
     void *first;
};
extern T      List_append (T list, T tail);
extern T      List_copy   (T list);
extern T      List_list   ( void *x, ...);
extern T      List_pop    (T list,  void **x);
extern T      List_push   (T list,  void *x);
extern T      List_reverse(T list);
extern  int    List_length (T list);
extern  void   List_free   (T *list);
extern  void   List_map    (T list,
     void apply( void **x,  void *cl),  void *cl);
extern  void **List_toArray(T list,  void *end);
#undef T
#endif
复制代码

 

list.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/list.doc,v 1.11 1997/02/21 19:46:01 drh Exp $ ";
#include <stdarg.h>
#include <stddef.h>
#include  " assert.h "
#include  " mem.h "
#include  " list.h "
#define T List_T
T List_push(T list,  void *x) {
    T p;
    NEW(p);
    p->first = x;
    p->rest  = list;
     return p;
}
T List_list( void *x, ...) {
    va_list ap;
    T list, *p = &list;
    va_start(ap, x);
     for ( ; x; x = va_arg(ap,  void *)) {
        NEW(*p);
        (*p)->first = x;
        p = &(*p)->rest;
    }
    *p = NULL;
    va_end(ap);
     return list;
}
T List_append(T list, T tail) {
    T *p = &list;
     while (*p)
        p = &(*p)->rest;
    *p = tail;
     return list;
}
T List_copy(T list) {
    T head, *p = &head;
     for ( ; list; list = list->rest) {
        NEW(*p);
        (*p)->first = list->first;
        p = &(*p)->rest;
    }
    *p = NULL;
     return head;
}
T List_pop(T list,  void **x) {
     if (list) {
        T head = list->rest;
         if (x)
            *x = list->first;
        FREE(list);
         return head;
    }  else
         return list;
}
T List_reverse(T list) {
    T head = NULL, next;
     for ( ; list; list = next) {
        next = list->rest;
        list->rest = head;
        head = list;
    }
     return head;
}
int List_length(T list) {
     int n;
     for (n =  0; list; list = list->rest)
        n++;
     return n;
}
void List_free(T *list) {
    T next;
    assert(list);
     for ( ; *list; *list = next) {
        next = (*list)->rest;
        FREE(*list);
    }
}
void List_map(T list,
     void apply( void **x,  void *cl),  void *cl) {
    assert(apply);
     for ( ; list; list = list->rest)
        apply(&list->first, cl);
}
void **List_toArray(T list,  void *end) {
     int i, n = List_length(list);
     void **array = ALLOC((n +  1)* sizeof (*array));
     for (i =  0; i < n; i++) {
        array[i] = list->first;
        list = list->rest;
    }
    array[i] = end;
     return array;
}
复制代码

 

第8章 表格

table.h

复制代码
/*  $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $  */
#ifndef TABLE_INCLUDED
#define TABLE_INCLUDED
#define T Table_T
typedef  struct T *T;
extern T    Table_new ( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *key));
extern  void Table_free(T *table);
extern  int   Table_length(T table);
extern  void *Table_put   (T table,  const  void *key,
     void *value);
extern  void *Table_get   (T table,  const  void *key);
extern  void *Table_remove(T table,  const  void *key);
extern  void   Table_map    (T table,
     void apply( const  void *key,  void **value,  void *cl),
     void *cl);
extern  void **Table_toArray(T table,  void *end);
#undef T
#endif
复制代码

 

 

table.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <limits.h>
#include <stddef.h>
#include  " mem.h "
#include  " assert.h "
#include  " table.h "
#define T Table_T
struct T {
     int size;
     int (*cmp)( const  void *x,  const  void *y);
    unsigned (*hash)( const  void *key);
     int length;
    unsigned timestamp;
     struct binding {
         struct binding *link;
         const  void *key;
         void *value;
    } **buckets;
};
static  int cmpatom( const  void *x,  const  void *y) {
     return x != y;
}
static unsigned hashatom( const  void *key) {
     return (unsigned  long)key>> 2;
}
T Table_new( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *key)) {
    T table;
     int i;
     static  int primes[] = {  509,  509,  1021,  2053,  4093,
         8191,  16381,  32771,  65521, INT_MAX };
    assert(hint >=  0);
     for (i =  1; primes[i] < hint; i++)
        ;
    table = ALLOC( sizeof (*table) +
        primes[i- 1]* sizeof (table->buckets[ 0]));
    table->size = primes[i- 1];
    table->cmp  = cmp  ?  cmp : cmpatom;
    table->hash = hash ? hash : hashatom;
    table->buckets = ( struct binding **)(table +  1);
     for (i =  0; i < table->size; i++)
        table->buckets[i] = NULL;
    table->length =  0;
    table->timestamp =  0;
     return table;
}
void *Table_get(T table,  const  void *key) {
     int i;
     struct binding *p;
    assert(table);
    assert(key);
    i = (*table->hash)(key)%table->size;
     for (p = table->buckets[i]; p; p = p->link)
         if ((*table->cmp)(key, p->key) ==  0)
             break;
     return p ? p->value : NULL;
}
void *Table_put(T table,  const  void *key,  void *value) {
     int i;
     struct binding *p;
     void *prev;
    assert(table);
    assert(key);
    i = (*table->hash)(key)%table->size;
     for (p = table->buckets[i]; p; p = p->link)
         if ((*table->cmp)(key, p->key) ==  0)
             break;
     if (p == NULL) {
        NEW(p);
        p->key = key;
        p->link = table->buckets[i];
        table->buckets[i] = p;
        table->length++;
        prev = NULL;
    }  else
        prev = p->value;
    p->value = value;
    table->timestamp++;
     return prev;
}
int Table_length(T table) {
    assert(table);
     return table->length;
}
void Table_map(T table,
     void apply( const  void *key,  void **value,  void *cl),
     void *cl) {
     int i;
    unsigned stamp;
     struct binding *p;
    assert(table);
    assert(apply);
    stamp = table->timestamp;
     for (i =  0; i < table->size; i++)
         for (p = table->buckets[i]; p; p = p->link) {
            apply(p->key, &p->value, cl);
            assert(table->timestamp == stamp);
        }
}
void *Table_remove(T table,  const  void *key) {
     int i;
     struct binding **pp;
    assert(table);
    assert(key);
    table->timestamp++;
    i = (*table->hash)(key)%table->size;
     for (pp = &table->buckets[i]; *pp; pp = &(*pp)->link)
         if ((*table->cmp)(key, (*pp)->key) ==  0) {
             struct binding *p = *pp;
             void *value = p->value;
            *pp = p->link;
            FREE(p);
            table->length--;
             return value;
        }
     return NULL;
}
void **Table_toArray(T table,  void *end) {
     int i, j =  0;
     void **array;
     struct binding *p;
    assert(table);
    array = ALLOC(( 2*table->length +  1)* sizeof (*array));
     for (i =  0; i < table->size; i++)
         for (p = table->buckets[i]; p; p = p->link) {
            array[j++] = ( void *)p->key;
            array[j++] = p->value;
        }
    array[j] = end;
     return array;
}
void Table_free(T *table) {
    assert(table && *table);
     if ((*table)->length >  0) {
         int i;
         struct binding *p, *q;
         for (i =  0; i < (*table)->size; i++)
             for (p = (*table)->buckets[i]; p; p = q) {
                q = p->link;
                FREE(p);
            }
    }
    FREE(*table);
}
复制代码

 

 

wf程序来统计单词的频率

getword.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <ctype.h>
#include < string.h>
#include <stdio.h>
#include  " assert.h "
#include  " getword.h "
int getword(FILE *fp,  char *buf,  int size,
     int first( int c),  int rest( int c)) {
     int i =  0, c;
    assert(fp && buf && size >  1 && first && rest);
    c = getc(fp);
     for ( ; c != EOF; c = getc(fp))
         if (first(c)) {
            {
                 if (i < size -  1)
                    buf[i++] = c;
            }
            c = getc(fp);
             break;
        }
     for ( ; c != EOF && rest(c); c = getc(fp))
        {
             if (i < size -  1)
                buf[i++] = c;
        }
     if (i < size)
        buf[i] =  ' \0 ';
     else
        buf[size- 1] =  ' \0 ';
     if (c != EOF)
        ungetc(c, fp);
     return i >  0;
}
复制代码

 

wf.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/table.doc,v 1.13 1997/10/27 23:10:11 drh Exp $ ";
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include  " atom.h "
#include  " table.h "
#include  " mem.h "
#include  " getword.h "
#include < string.h>
void wf( char *, FILE *);
int first( int c);
int rest ( int c);
int compare( const  void *x,  const  void *y);
void vfree( const  void *,  void **,  void *);
int main( int argc,  char *argv[]) {
     int i;
     for (i =  1; i < argc; i++) {
        FILE *fp = fopen(argv[i],  " r ");
         if (fp == NULL) {
            fprintf(stderr,  " %s: can't open '%s' (%s)\n ",
                argv[ 0], argv[i], strerror(errno));
             return EXIT_FAILURE;
        }  else {
            wf(argv[i], fp);
            fclose(fp);
        }
    }
     if (argc ==  1) wf(NULL, stdin);
     return EXIT_SUCCESS;
}
void wf( char *name, FILE *fp) {
    Table_T table = Table_new( 0, NULL, NULL);
     char buf[ 128];
     while (getword(fp, buf,  sizeof buf, first, rest)) {
         const  char *word;
         int i, *count;
         for (i =  0; buf[i] !=  ' \0 '; i++)
            buf[i] = tolower(buf[i]);
        word = Atom_string(buf);
        count = Table_get(table, word);
         if (count)
            (*count)++;
         else {
            NEW(count);
            *count =  1;
            Table_put(table, word, count);
        }
    }
     if (name)
        printf( " %s:\n ", name);
    {  int i;
       void **array = Table_toArray(table, NULL);
      qsort(array, Table_length(table),  2* sizeof (*array),
          compare);
       for (i =  0; array[i]; i +=  2)
          printf( " %d\t%s\n ", *( int *)array[i+ 1],
              ( char *)array[i]);
      FREE(array); }
    Table_map(table, vfree, NULL);
    Table_free(&table);
}
int first( int c) {
     return isalpha(c);
}
int rest( int c) {
     return isalpha(c) || c ==  ' _ ';
}
int compare( const  void *x,  const  void *y) {
     return strcmp(*( char **)x, *( char **)y);
}
void vfree( const  void *key,  void **count,  void *cl) {
    FREE(*count);
}
复制代码

 

第9章 集合

集合的实现

set.h

复制代码
/*  $Id: H:/drh/idioms/book/RCS/set.doc,v 1.11 1996/06/26 23:02:01 drh Exp $  */
#ifndef SET_INCLUDED
#define SET_INCLUDED
#define T Set_T
typedef  struct T *T;
extern T    Set_new ( int hint,
     int cmp( const  void *x,  const  void *y),
    unsigned hash( const  void *x));
extern  void Set_free(T * set);
extern  int   Set_length(T  set);
extern  int   Set_member(T  set,  const  void *member);
extern  void  Set_put   (T  set,  const  void *member);
extern  void *Set_remove(T  set,  const  void *member);
extern  void   Set_map    (T  set,
     void apply( const  void *member,  void *cl),  void *cl);
extern  void **Set_toArray(T  set,  void *end);
extern T Set_union(T s, T t);
extern T Set_inter(T s, T t);
extern T Set_minus(T s, T t);
extern T Set_diff (T s, T t);
#undef T
#endif
复制代码

 

 

set.c

复制代码
static  char rcsid[] =  " $Id: H:/drh/idioms/book/RCS/set.doc,v 1.11 1996/06/26 23:02:01 drh Exp $ ";
#include <limits.h>
#include <stddef.h>
#include  "
最低0.47元/天 解锁文章
《c语言接口与实现》读后感
东南飞的专栏
04-13 2万+
  在网上看过一篇文章叫《c编程的四书五经》，中间就包括这本书。我推荐要好好研究c的朋友好好看看这本书。这本书用c进行数据结构的封装。其基本思想就是一个数据结构和围绕它操作的一族函数。只要学过c语言的人，对于自己封装这样的链表或堆栈一定觉得不是难事，但是很少有人像本书作者做的如此通用。这本书是lcc的作者写的，其源码可以在国外的网站下载到，china-pub有链接。  书中对atom,list
c语言接口与实现作用,《C语言接口与实现》
weixin_34553415的博客
05-16 542
这本书买了很久了，可能是研究生的时候凑单买的，从来没有翻过。前两天看一个书单推荐这本书，于是拿来看看讲的什么内容。这本书是个外国人写的，计算机类的书我们一般迷信外国人，外国人也从来没让我们失望过，这本书也不例外。接口之所以重要，是因为接口定义了模块的行为，是模块的边界所在。这本书可以看作是接口设计的范本。书中介绍的接口种类非常多，适用于几乎所有接口类型。这里的接口不是组件间接口，也不是跨领域跨子系...
C语言API实用手册：深入编程核心
最新发布
weixin_35987118的博客
09-20 702
本文还有配套的精品资源，点击获取 简介：标准C语言API是C语言编程的核心，它提供了一系列函数和接口来实现内存管理、输入输出、字符串处理、数学运算等基本功能。本指南将详细介绍C语言的基础数据类型、内存操作、I/O操作、字符串处理、数学函数、指针和内存操作、错误处理、结构体与联合体、预处理指令、类型定义、函数原型以及位操作等关键知识点，帮助开发者构建高效、可靠的程序。 ...
C语言-接口与实现
热门推荐
智小星的博客
07-23 3万+
1. 模块化编程 面向对象编程是一种思想，和语言无关。学过C++、java等面向对象编程语言的同学，应该都知道面向对象的三大特性是封装、继承和多态。而C语言一直被蒙上了面向过程编程的面纱。工作后从事的是嵌入式软件开发，在开发过程中运用最多的还是C语言，所以在程序的设计过程中，一直想使用C语言达到面向对象编程的效果，这里将讲解使用C语言来模拟面向对象编程的实现。 在项...
c语言接口与实现作用,C语言接口与实现
weixin_32427105的博客
05-16 528
出版信息(美)David R. Hanson / 人民邮电出版社 / 2010-8 / 79.00元内容简介可重用的软件模块是构建大规模可靠应用程序的基石，创建可重用的软件模块是每个程序员和项目经理必须掌握的技能。C语言对创建可重用的API提供的语言和功能支持非常少，虽然C程序员写应用时都会用到API和库，但却很少有人去创建和发布新的能广泛应用的API。本书介绍用一种基于接口的设计方法创建可重用的...
C语言接口与实现 c语言
10-07
对于c语言接口网上的资料是少之又少，所以下面这些文字全是我一个字一个字打印上来的希望大家 能对的起我的付出： 现在的程序员都面临大量的关于应用程序接口（Application Programming Interface,API) 的信息，大多数人都会使用API和程序库，并在其所写的每一个应用程序中实现它们，但是很少人 会创建或发布新的能广泛应用的API，事实上，程序员似乎倾向与循环使用他们自己的东西，而不 愿意查找，能满足他们要求的程序库，这或许是因为写特定应用程序代码要比查找设计好的API容易。 这里我所提到的是一种基于接口与其实现的设计方法，并且通过对24个接口及其实现的描述详细地演示了这种方法，这些接口涉及到计算机领域的很多知识，其中包括数据结构，算法，字符串处理 和并发程序，这些实现并不是简单的玩具----它们是为了在你们所设计的软件代码中使用而设计的。（当然了我会通过阅读量来看是否继续发下去，人要少了我就没有必要浪费时间了） c编程语言对基于接口设计方法的支持是极少的。 而面向对象的语言，如c++,Modula-3,则鼓励将接口与实现分离，基于接口的设计独立与任何特定 的语言，但是它要求程序员对像c一样的语言有更多的驾驭能力和更高的警惕性，因为这类语言很容易破坏带有隐含实现信息的接口，反之亦然。 然而一但掌握了基于接口的设计方法，就能够在服务于众多应用程序的通用接口基础上建立应用程序，从而加速开发，在一些c++环境中的基础类库就体现了这种效果。 增加对现有软件的重用---接口实现库，能够减少初始开发成本，同时还能减少维护成本，因为应用程序的更多部分都建立在经过良好测试的通用接口的实现上，这里我提到的接口是针对数据结构的，但它并不是数据结构，我重点将放在算法引擎----包装数据结构以供应用程序使用----而不在数据结构算法本身，接口的示例和实现都以literate程序的方式给出，换句话说就是源代码及其解释是按照最适合理解代码的顺序交织出现的。 下面我将我想要给大家讲的内容分一下类： 基础 1，接口与实现 2，异常与断言 3，内寸管理 4，进一步内寸管理 数据结构 5，链表 6，表格 7，集合 8，动态数组 9，序列 10，环 11，位向量 字符串 12，原子 13，格式化 14，低级字符串 15，高级字符串 算法 16，扩展精度算法 17，任意精度算法 18，多精度算法 线程 19，线程 建议： 看到这里的朋友我相信对c语言都有了很长时间的学习 如果你还没有搞懂c语言的全部内容，我强烈建议你先别看这里
C语言接口与实现+算法引论
08-16
本文件包含《C语言接口与实现》与《算法引论：一种创造性方法》。 《C语言接口与实现》：一本有关设计、实现和有效使用C语言库函数，掌握创建可重用C语言软件模块技术的参考指南。 《算法引论：一种创造性方法》：一...
C语言接口与实现方法实例详解
09-04
【C语言接口与实现方法实例详解】 在C语言编程中，接口和实现是软件设计中的两个关键概念。接口定义了模块对外提供的服务，而实现则是完成这些服务的具体代码。理解和熟练掌握这两个概念对于编写可维护、可扩展的...
[C语言接口与实现_C语言接口实现_
10-02
在商业化的进程中， 美国的产业界与教育界越来越紧密地结合， 计算机学科中的许多泰山北斗同时身处科研和教学的最前线， 由此而产生的经典科学著作， 不仅擘划了研究的范畴， 还揭橥了学术的源变， 既遵循学术规范，...
C语言接口与实现 创建可重用软件的技术.pdf
07-12
C语言接口与实现 创建可重用软件的技术
cii:《 C语言接口与实现》源代码集
03-23
《C语言接口与实现》是一本深入探讨C语言编程的经典著作，主要关注的是C语言的接口设计和实现原理。这个源代码集包含了书中所讲解的各种示例和实践代码，为读者提供了直观的理解材料。虽然代码没有注释，但是通过与...
C语言接口与实现C语言接口与实现C语言接口与实现
03-15
自己看啦自己看啦自己看啦自己看啦自己看啦自己看啦自己看啦自己看啦
C语言接口与实现
02-20
可重用的软件模块是构建大规模可靠应用程序的基石，创建可重用的软件模块是每个程序员和项目经理必须掌握的技能。C语言对创建可重用的API提供的语言和功能支持非常少，虽然C程序员写应用时都会用到API和库，但却很少有人去创建和发布新的能广泛应用的API。本书介绍用一种基于接口的设计方法创建可重用的API，这一方法将接口与实现分离开来，且与语言无关。书中详细描述了24个接口及其实现，便于读者深入了解此方法。这些接口涉及很多计算机领域的知识，包括数据结构、算法、字符串处理和并发程序。 本书是C语言领域的经典名著，出版十余年仍畅销不衰，是几代程序员倍加推崇的力作。
c语言接口与实现
10-04
　　现今生活中接口的作用越来越重要，在程序设计中实现接口是非常重要的，有兴趣的兄弟们可以看看!
C语言接口与实现 - 创建可重用软件的技术中英两本
12-21
C语言接口与实现 - 创建可重用软件的技术中文版和英文版C.Interfaces.And.Implementations.Techniques.For.Creating.Reusable.Software),.Hanson
读书笔记--C语言接口与实现--接口与实现
白驹过隙
04-06 8573
接口实现重点内容在本书中的第二章中，介绍了接口的封装例子。1. 接口定义C语言中可将接口封装好，让后以.h文件作文扩展，简单例子：extern int Arith_max(int x, int y); extern int Arith_min(int x, int y); extern int Arith_div(int x, int y); extern int Arith_mod(int x,
C语言接口与实现：编程风格与效率探索
"《C语言接口与实现》是一本深入探讨C语言编程风格、接口设计、实现策略以及效率优化的书籍。书中通过多个章节详细阐述了如何构建清晰、高效的C程序，涵盖了原子操作、异常处理、内存管理等多个关键主题。" 在本书...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值