程式師世界 >> 編程語言 >> C語言 >> C++ >> 關於C++ >> C說話接口與完成辦法實例詳解

C說話接口與完成辦法實例詳解

編輯：關於C++

C說話接口與完成辦法實例詳解。本站提示廣大學習愛好者：（C說話接口與完成辦法實例詳解）文章只能為提供參考，不一定能成為您想要的結果。以下是C說話接口與完成辦法實例詳解正文

本文以實例情勢具體講述了C說話接口與完成辦法，關於深刻控制C說話法式設計有必定的自創價值。分享給年夜家供年夜家參考。詳細剖析以下：

普通來講，一個模塊有兩部門構成：接口和完成。接口指明模塊要做甚麼，它聲清楚明了應用該模塊的代碼可用的標識符、類型和例程，完成指明模塊是若何完成其接口聲明的目的的，一個給定的模塊平日只要一個接口，然則能夠會有很多種完成可以或許供給接口所指定的功效。每一個完成能夠應用分歧的算法和數據構造，然則它們都必需相符接口所給出的應用解釋。客戶挪用法式是應用某個模塊的一段代碼，客戶挪用法式導入接口，而完成導出接口。因為多個客戶挪用法式是同享接口和完成的，是以應用完成的目的代碼防止了不用要的代碼反復，同時也有助於防止毛病，由於接口和完成只需一次編寫和調試便可屢次應用。

接口

接口只須要指明客戶挪用法式能夠應用的標識符便可，應盡量地隱蔽一些有關的表現細節和算法，如許客戶挪用法式可以不用依附於特定的完成細節。這類客戶挪用法式和完成之間的依附--耦合----能夠會在完成轉變時惹起毛病，當這類依附性埋藏在一些關於完成隱蔽的或是不明白的假定中時，這些毛病能夠很難修復，是以一個設計優越且描寫准確的接口應當盡可能削減耦合。

C說話對接口和完成的分別只供給最根本的支撐，然則簡略的商定能給接口/完成辦法論帶來偉大的利益。在C中，接口在頭文件聲明，頭文件聲清楚明了客戶挪用法式可使用的宏、類型、數據構造、變量和例程。用戶應用C說話的預處置指令#include導入接口。

上面的例子解釋了本篇文章的接口中所應用的一些商定、接口：

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，接行動文件也響應地定名為arith.h，接口的名字之前綴的情勢湧現在接口的每一個標識符中。模塊名不只供給了適合的前綴，並且還有助於整頓客戶挪用法式代碼。

Arith接口還供給了一些尺度C函數庫中沒有然則很有效的函數，並為動身和取模供給了優越的界說，而尺度C中並沒有給出這些操作的界說和只供給基於完成的界說。

完成

一個完成導出一個接口，它界說了需要的變量和函數以供給接口所劃定的功效，在C說話中，一個完成是由一個或多個.c文件供給的，一個完成必需供給其導出的接口所指定的功效。完成應包括接口的.h文件，以包管它的界說和接口的聲明時分歧的。

Arith_min和Arith_max前往其整型參數中的最小值和最年夜值：

int Arith_max(int x, int y) {
  return x > y ? x : y;
}
int Arith_min(int x, int y) {
  return x > y ? y : x;
}

Arith_div前往y除以x獲得的商，Arith_mod前往響應的余數。當x與y同號的時刻，Arith_div(x,y)等價於x/y，Arith_mod(x,y)等價於x%y

當x與y的符號分歧的時刻，C的內嵌操作的前往值就取決於詳細的完成：

假如-13/5=2，-13%5=-3，假如-13/5=-3，-13%5=2

尺度庫函數老是向零取整，是以div(-13,2)=-2，Arith_div和Arith_mod的語義異樣界說好了：它們老是趨近數軸的左邊取整，是以Arith_div(-13,5）=-3，Arith_div(x,y)是不跨越實數z的最年夜整數，個中z知足z*y=x。

Arith_mod(x,y)被界說為x-y*Arith_div(x,y)。是以Arith_mod(-13,5)=-13-5*(-3)=2

函數Arith_ceiling和Arith_floor遵守相似的商定，Arith_ceiling(x,y)前往不小於實數商x/y的最小整數

Arith_floor(x,y)前往不跨越實數商x/y的最年夜整數

完全完成代碼以下：

#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);
}

籠統數據類型

籠統數據類型（abstract data type,ADT）是一個界說了數據類型和基於該類型值供給的各類操作的接口

一個高等類型是籠統的，由於接口隱蔽了它的表現細節，以避免客戶挪用法式依附這些細節。上面是一個籠統數據類型（ADT）的標准化例子--客棧，它界說了該類型和五種操作：

#ifndef STACK_INCLUDED
#define STACK_INCLUDED
#define T Stack_T
typedef struct T *T;
extern T   Stack_new (void);
extern int  Stack_empty(T stk);
extern void Stack_push (T stk, void *x);
extern void *Stack_pop (T stk);
extern void Stack_free (T *stk);
#undef T
#endif

完成

包括相干頭文件：

#include <stddef.h>
#include "assert.h"
#include "mem.h"
#include "stack.h"
#define T Stack_T

Stack_T的外部是一個構造，該構造有個字段指向一個棧內指針的鏈表和一個這些指針的計數：

struct T {
  int count;
  struct elem {
    void *x;
    struct elem *link;
  } *head;
};

Stack_new分派並初始化一個新的T：

T Stack_new(void) {
  T stk;
  NEW(stk);
  stk->count = 0;
  stk->head = NULL;
  return stk;
}

個中NEW是一個另外一個接口中的一個分派宏指令。NEW(p)將分派該構造的一個實例，並將其指針賦給p，是以Stack_new中應用它便可以分派一個新的Stack_T

當count=0時，Stack_empty前往1，不然前往0：

int Stack_empty(T stk) {
  assert(stk);
  return stk->count == 0;
}

assert(stk)完成了可檢討的運轉期毛病，它制止空指針傳給Stack中的任何函數。

Stack_push和Stack_pop從stk->head所指向的鏈表的頭部添加或移出元素：

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;
}

FREE是另外一個接口中界說的釋放宏指令，它釋放指針參數所指向的空間，然後將參數設為空指針

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);
}

完全完成代碼以下：

#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);
}

信任本文所述對年夜家的C法式設計有必定的自創價值。

關於C++