《C現代程式設計》第三章面向物件

阿新 • • 發佈：2018-12-21

3.2 C的模組化與面向物件

生成一個棧的結構體，包括棧的元素；棧的初始化newStack()，棧的壓入push(); 棧的取出pop()

stack.h 檔案
#ifndef _STACK_H_
#define _STACK_H_

#include <stddef.h>

#ifdef _cplusplus
extren "C"
{
#endif

	typedef struct
	{
		int top;
		const size_t size;
		int *const pBuf;
	}Stack;

	bool push(Stack *p , int val);
	bool pop(Stack *p, int *pRet);

#define newStack(buf){				\
		0,							\
		sizeof(buf) / sizeof(int),	\
		buf							\
	}

#ifdef _cplusplus
}
#endif
#endif 
注意：

使用extern "C"可使C++順利呼叫C函式，同時#ifdef __cplusplus是為了告訴編譯器，extern "C" 僅在C++中編譯時才有效。C++標準規定了在C++中編譯時，__cplusplus標示符才會被定義，如下：#ifdef __cplusplus

extern "C"

{

#endif

//中間程式碼

#ifdef __cplusplus

}

#endif

巨集定義時候用的 \ 是連線的意思。

stack.cpp 檔案

#include "stack.h"

static bool isNull(void *p)
{
	if (NULL == p)
	{
		return true;
	}
	return false;
}
static bool isStackFull(Stack *p)
{
	if (p->top == p->size)
	{
		return true;
	}
	else
	{
		return false;
	}	
}
static bool isStackEmpty(Stack *p)
{
	if (0 == p->top)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//成功返回true;失敗返回false
bool push(Stack *p, int val)
{
	if (isStackFull(p))
	{
		return false;
	}
	else
	{
		p->pBuf[p->top++] = val;
	}
	return true;
}
//成功返回true;失敗返回false
bool pop(Stack *p, int *pRet)
{
	if (isStackEmpty(p)||isNull(pRet))
	{
		return false;
	}
	else
	{
		*pRet = p->pBuf[--p->top];
	}
	return true;
}

我們輸出執行一下

#include<stdio.h>
#include "stack.h"
int main()
{
	int buf[16];
	Stack stack = newStack(buf);
	for (int i = 1; i < 18;i++)
	{
		if (!push(&stack, i))
		{
			printf("stack is full !\n");
		}
	}
	int buff[16];
	for (int i = 0; i < 16;i++)
	{
		if (pop(&stack , &buff[i]))
		{
			printf("buff[%d]:%d\n", i ,buff[i]);
		}
	}
	return 0;
}

可以看出棧是壓入的，取出是從頂部取出來。

3.2.1 設定壓入範圍

stack.h 檔案

#ifndef _STACK_H_
#define _STACK_H_
//生成一個棧的結構體
#include <stddef.h>

#ifdef _cplusplus
extren "C"
{
#endif

	typedef struct
	{
		const int min;
		const int max;
	}Range;

	typedef struct
	{
		int top;
		const size_t size;
		int *const pBuf;
		const Range* const pRange;
	}Stack;

	bool push(Stack *p , int val);
	bool pop(Stack *p, int *pRet);

#define newStack(buf){				\
		0,							\
		sizeof(buf) / sizeof(int),	\
		buf,						\
		NULL						\
	}
#define newStackWitchRange(buf , pRange){		\
		0,										\
		sizeof(buf) / sizeof(int),				\
		buf,									\
		pRange									\
	}

#ifdef _cplusplus
}
#endif
#endif

stack.cpp 檔案

#include "stack.h"

static bool isNull(void *p)
{
	if (NULL == p)
	{
		return true;
	}
	return false;
}
static bool isStackFull(Stack *p)
{
	if (p->top == p->size)
	{
		return true;
	}
	else
	{
		return false;
	}	
}
static bool isStackEmpty(Stack *p)
{
	if (0 == p->top)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//輸入範圍檢擦
static bool isRangeOk(const Range *p , int val)
{
	if (isNull((void *)p) || (p->max >= val && val >= p->min))
	{
		return true;
	}
	return false;
}
//成功返回true;失敗返回false
bool push(Stack *p, int val)
{
	if (isStackFull(p) || !isRangeOk( p->pRange, val))
	{
		return false;
	}
	else
	{
		p->pBuf[p->top++] = val;
	}
	return true;
}
//成功返回true;失敗返回false
bool pop(Stack *p, int *pRet)
{
	if (isStackEmpty(p)||isNull(pRet))
	{
		return false;
	}
	else
	{
		*pRet = p->pBuf[--p->top];
	}
	return true;
}

mian .cpp 檔案

#include<stdio.h>
#include "stack.h"
int main()
{
	int buf[16];
	Range range = {0 , 9};//
	Stack stack = newStackWitchRange(buf, &range);;//
	for (int i = 1; i < 18;i++)
	{
		if (!push(&stack, i))
		{
			printf("stack is full !\n");
		}
	}
	int buff[16];
	for (int i = 0; i < 16;i++)
	{
		if (pop(&stack , &buff[i]))
		{
			printf("buff[%d]:%d\n", i ,buff[i]);
		}
	}
	return 0;
}

執行結果如上；

引入校驗器 Validtor

stack.h 檔案

#ifndef _STACK_H_
#define _STACK_H_
//生成一個棧的結構體
#include <stddef.h>

#ifdef _cplusplus
extren "C"
{
#endif
	typedef struct Validator
	{
		bool(*const validate)(struct Validator *pThis , int val);
		void *pData;
	}Validator;//新增

	typedef struct
	{
		const int min;
		const int max;
	}Range;

	typedef struct
	{
		int previousValue;
		
	}PreviousValue;//新增

	typedef struct
	{
		int top;
		const size_t size;
		int *const pBuf;
		//const Range* const pRange;
		Validator *const pValidator;//新增
	}Stack;

	bool push(Stack *p , int val);
	bool pop(Stack *p, int *pRet);

	bool validateRange(Validator *pThis , int val);//新增
	bool vaidatePrevious(Validator *pThis, int val);//新增

#define newStack(buf){				\
		0,							\
		sizeof(buf) / sizeof(int),	\
		buf,						\
		NULL						\
	}

#define rangeValidator(pRange){\
		validateRange,\
		pRange\
	}/*對應函式bool validateRange(Validator *pThis , int val)*/

#define previousValidator(pPrevious){\
		vaidatePrevious,\
		pPrevious\
		}/*bool vaidatePrevious(Validator *pThis, int val);*/

#define newStackWitchValidator(buf , pValidator){	\
		0,										\
		sizeof(buf) / sizeof(int),				\
		buf,									\
		pValidator								\
	}//修改

#ifdef _cplusplus
}
#endif
#endif

stack.cpp 檔案

#include "stack.h"

static bool isNull(void *p)
{
	if (NULL == p)
	{
		return true;
	}
	return false;
}
static bool isStackFull(Stack *p)
{
	if (p->top == p->size)
	{
		return true;
	}
	else
	{
		return false;
	}	
}
static bool isStackEmpty(Stack *p)
{
	if (0 == p->top)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//輸入範圍檢擦,【函式失效】
//static bool isRangeOk(const Range *p , int val)
//{
//	if (isNull((void *)p) || (p->max >= val && val >= p->min))
//	{
//		return true;
//	}
//	return false;
//}
bool validateRange(Validator *pThis, int val)//新增
{
	if (!isNull(pThis))
	{
		Range *pRange = (Range *)pThis->pData;
		if (pRange->max >= val && val >= pRange->min)
		{
			return true;
		}
	}
	return false;
}
bool vaidatePrevious(Validator *pThis, int val)//新增
{
	if (!isNull(pThis))
	{
		PreviousValue *pPrevious = (PreviousValue *)pThis->pData;
		if (val > pPrevious->previousValue)
		{
			pPrevious->previousValue = val;
			return true;
		}
	}
	return false;
}
//成功返回true;失敗返回false
bool push(Stack *p, int val)
{
	if (isStackFull(p) || !(p->pValidator->validate(p->pValidator , val)))
	{
		return false;
	}
	else
	{
		p->pBuf[p->top++] = val;
	}
	return true;
}
//成功返回true;失敗返回false
bool pop(Stack *p, int *pRet)
{
	if (isStackEmpty(p)||isNull(pRet))
	{
		return false;
	}
	else
	{
		*pRet = p->pBuf[--p->top];
	}
	return true;
}

main.cpp 檔案

#include<stdio.h>
#include "stack.h"
int main()
{
	int buf[16];
	Range range = {0 , 15};
	Validator validator = rangeValidator(&range);//新增
	Stack stack = newStackWitchValidator(buf, &validator);//修改
	for (int i = 1; i < 17;i++)
	{
		if (!push(&stack, i))
		{
			printf("stack is full !\n");
		}
	}
	int buff[16];
	for (int i = 0; i < 16;i++)
	{
		if (pop(&stack , &buff[i]))
		{
			printf("buff[%d]:%d\n", i ,buff[i]);
		}
	}
	return 0;
}

執行效果如下：

保證了原有功能的實現，下面是PreviousValitoar 校驗器的使用：

#include<stdio.h>
#include "stack.h"
int main()
{
	int buf[16];
	//Range range = {0 , 15};
	//Validator validator = rangeValidator(&range);//新增
	PreviousValue Previous = {9};
	Validator validator = previousValidator(&Previous);//新增
	Stack stack = newStackWitchValidator(buf, &validator);//修改
	for (int i = 1; i < 17;i++)
	{
		if (!push(&stack, i))
		{
			printf("stack is full !\n");
		}
	}
	int buff[16];
	for (int i = 0; i < 16;i++)
	{
		if (pop(&stack , &buff[i]))
		{
			printf("buff[%d]:%d\n", i ,buff[i]);
		}
	}
	return 0;
}

執行效果下圖

實現兩種驗證器合併：

stack.h檔案

#ifndef _STACK_H_
#define _STACK_H_
//生成一個棧的結構體
#include <stddef.h>

#ifdef _cplusplus
extren "C"
{
#endif
	typedef struct Validator
	{
		bool(*const validate)(struct Validator *pThis , int val);
		void *pData;
	}Validator;//

	typedef struct
	{
		const int min;
		const int max;
	}Range;

	typedef struct
	{
		int previousValue;
		
	}PreviousValue;//

	typedef struct
	{
		Range *Pange;
		PreviousValue *Previous;
	}RangeWithPrevious;//新增

	typedef struct
	{
		int top;
		const size_t size;
		int *const pBuf;
		//const Range* const pRange;
		Validator *const pValidator;//
	}Stack;

	bool push(Stack *p , int val);
	bool pop(Stack *p, int *pRet);

	bool validateRange(Validator *pThis , int val);//
	bool vaidatePrevious(Validator *pThis, int val);//
	bool vaidateRangePrevious(Validator *pThis, int val);//新增

#define newStack(buf){\
		0,\
		sizeof(buf) / sizeof(int),\
		buf,\
		NULL\
	}

#define rangeValidator(pRange){\
		validateRange,\
		pRange\
	}/*對應函式bool validateRange(Validator *pThis , int val)*/

#define previousValidator(pPrevious){\
		vaidatePrevious,\
		pPrevious\
		}/*bool vaidatePrevious(Validator *pThis, int val);*/

#define rangePreviousValidator(pRangePrevious){\
		vaidateRangePrevious,\
		pRangePrevious\
		}/*bool vaidateRangePrevious(Validator *pThis, int val);*/

#define newStackWitchValidator(buf , pValidator){\
		0,\
		sizeof(buf) / sizeof(int),\
		buf,\
		pValidator\
	}

#ifdef _cplusplus
}
#endif
#endif

stack.cp 檔案

#include "stack.h"

static bool isNull(void *p)
{
	if (NULL == p)
	{
		return true;
	}
	return false;
}
static bool isStackFull(Stack *p)
{
	if (p->top == p->size)
	{
		return true;
	}
	else
	{
		return false;
	}	
}
static bool isStackEmpty(Stack *p)
{
	if (0 == p->top)
	{
		return true;
	}
	else
	{
		return false;
	}
}
//輸入範圍檢擦,【函式失效】
//static bool isRangeOk(const Range *p , int val)
//{
//	if (isNull((void *)p) || (p->max >= val && val >= p->min))
//	{
//		return true;
//	}
//	return false;
//}
bool validateRange(Validator *pThis, int val)//
{
	if (!isNull(pThis))
	{
		Range *pRange = (Range *)pThis->pData;
		if (pRange->max >= val && val >= pRange->min)
		{
			return true;
		}
	}
	return false;
}
bool vaidatePrevious(Validator *pThis, int val)//
{
	if (!isNull(pThis))
	{
		PreviousValue *pPrevious = (PreviousValue *)pThis->pData;
		if (val > pPrevious->previousValue)
		{
			pPrevious->previousValue = val;
			return true;
		}
	}
	return false;
}
bool vaidateRangePrevious(Validator *pThis, int val)//新增
{
	if (!isNull(pThis))
	{ 
		RangeWithPrevious *pPreviousRange = (RangeWithPrevious *)pThis->pData;
		if ((val >pPreviousRange->Previous->previousValue)
			&&(pPreviousRange->Pange->max >= val && val >= pPreviousRange->Pange->min))
		{
			return true;
		}
	}
	return false;
}
//成功返回true;失敗返回false
bool push(Stack *p, int val)
{
	if (isStackFull(p) || !(p->pValidator->validate(p->pValidator , val)))
	{
		return false;
	}
	else
	{
		p->pBuf[p->top++] = val;
	}
	return true;
}
//成功返回true;失敗返回false
bool pop(Stack *p, int *pRet)
{
	if (isStackEmpty(p)||isNull(pRet))
	{
		return false;
	}
	else
	{
		*pRet = p->pBuf[--p->top];
	}
	return true;
}

mian.cpp 檔案

#include<stdio.h>
#include "stack.h"
int main()
{
	int buf[16];
	Range range = {0 , 15};//
	//Validator validator = rangeValidator(&range);
	PreviousValue Previous = {2};
	RangeWithPrevious rangePrevious = { &range, &Previous };
	Validator validator = rangePreviousValidator(&rangePrevious);
	Stack stack = newStackWitchValidator(buf, &validator);
	for (int i = 1; i < 17;i++)
	{
		if (!push(&stack, i))
		{
			printf("stack is full !\n");
		}
	}
	int buff[16];
	for (int i = 0; i < 16;i++)
	{
		if (pop(&stack , &buff[i]))
		{
			printf("buff[%d]:%d\n", i ,buff[i]);
		}
	}
	return 0;
}

執行結果如下：

可以從執行結果上看出輸入範圍在 0··15 之間，輸入必須從大於的2 開始

《C現代程式設計》第三章面向物件

3.2 C的模組化與面向物件生成一個棧的結構體，包括棧的元素；棧的初始化newStack()，棧的壓入push(); 棧的取出pop() stack.h 檔案 #ifndef _STACK_H_ #define _STACK_H_ #include <s

Java學習之第三章——面向物件程式設計

學習面向物件(OOP)內容的三條主線 1.java類及類的成員 2.面向物件的三大特徵（封裝 Encapsulation,繼承 Inheritance,多型 Polymorphism） 3.其他關鍵字 OOP:Object Oriented Programming

C#高階程式設計第三章讀書筆記

一，結構1.結構struct是儲存線上程棧中，類是儲存在託管堆中，成員變數少的時候可以考慮使用結構2.結構的成員變數不允許直接賦值，結構的建構函式不允許不帶參，實際上結構有一個預設的不帶參的建構函式，會把成員變數賦值，值型別為0，引用型別為null3.結構和int一樣，不用n

Python核心程式設計(第十三章)--面向物件程式設計

面向物件程式設計主要是類和類的例項建立類： class MyNewObjectType(bases): 'define MyNewObjectType class' class_suite 關鍵詞是class，緊接著是一個類名，隨後是定義類的類體程式碼 o

C語言程式設計第三章習題三

3.1 (1)（float)(a*b）/2)=18.000000 (int)%(int)y=2 (2)P=32 q=80 x=33 y=80 3.2 1#include<stdio.h> 2main() 3{ 4 intx=123,a,b,c,su

C++沉思錄第八章面向物件程式範例

c++沉思錄第八章的示例程式很有意思。程式雖小，卻很好地詮釋了面向物件程式設計的思想。正如書上說的仔細研究還是有所收穫的。先上程式碼 code Expr_node.h #pragma once #include "Expr.h" #incl

《Java併發程式設計實踐——第三章(共享物件)》

共享物件## 編寫正確的併發程式的關鍵在於對共享的、可變的物件狀態進行訪問管理。上一章使用同步來避免多個執行緒在同一時間訪問同一資料。同步還有另外的方面：記憶體可見性。 3.1 可見性 public class NoVisibility { private static

第八章面向物件程式設計

Python3.5筆記第8章面向物件程式設計面向物件術語介紹類：用來描述具有相同屬性和方法的物件的集合。類定義中集合了每個物件共有的屬性和方法。物件是類的示例。類變數（屬性）：類屬性在整個例項化的物件中是公用的。類變數定義在類中，且在方法之外。類常亮

C Primer Plus 第三章程式設計練習

1.通過試驗（即編寫帶有此類問題的程式）觀察系統如何處理整數上溢、浮點數上溢和浮點數下溢的情況。 #include<stdio.h> int main(void) { unsigned int a = 4294967295; float b = 3.4e38; flo

第6 章面向物件的程式設計

本章內容  理解物件屬性  理解並建立物件  理解繼承我們可以把 ECMAScript 的物件想象成散列表：無非就是一組名值對，其中值可以是資料或函式。 1 理解物件建立自定義物件的最簡單方式就是建立一個 Object 的例項，然後再為它新增屬性和

高質量嵌入式Linux C程式設計第三章運算子、表示式學習

一、運算子有哪幾類？（1）算數運算子：+、-、*、/、%、++、–七種（2）關係運算符：>、<、==、>=、<=、！=六種（3）邏輯運算子：&&、||、！三種（4）位操作運算子：&、|、~、^、<&l

C++11多執行緒程式設計第三章: 如何向執行緒傳參

C++11 Multithreading – Part 3: Carefully Pass Arguments to Threads Varun January 22, 2015 C++11 Multithreading – Part 3: Carefully Pass Ar

C++primer plus 第三章程式設計練習

本人用code::block 編寫，如需參考，善用Ctrl+shift+C 和 Ctrl + shift + X 快捷鍵如有任何錯誤或疑問，歡迎留言 ////3.1 inches to feet //#include <iostream> //co

第8章面向物件程式設計

本章知識點： 1、類和物件； 2、屬性和方法； 3、繼承和組合； 4、類的多型性； 5、類的訪問許可權； 6、設計模式的應用；內容： 8.1 面向物件的概念 1、用例圖2、活動圖3、狀態圖4、類圖5、序列圖和協助圖6、組建圖和部署圖 8.2 類和物件 8.2.1 類和物件的區別 8.

Kotlin極簡教程：第7章面向物件程式設計

在前面的章節中，我們學習了Kotlin的語言基礎知識、型別系統、集合類以及泛型相關的知識。在本章節以及下一章中，我們將一起來學習Kotlin對面向物件程式設計以及函數語言程式設計的支援。 7.1 面向物件程式設計思想 7.1.1 一切皆是對映《易

C++高階程式設計第九章: 精通類和物件

本章節最主要講了在類的構造和析構方面, 記憶體是怎樣分配的, 還有幾個關鍵字 : static, const, virtual, inline, 各種過載等等知識點. 1. 究竟什麼時候需要自己寫建構函式, 賦值函式, 拷貝建構函式? 只要你寫的這個類,

《Python核心程式設計》第13章面向物件程式設計練習

13-3.對類進行定製。寫一個類，用來將浮點型值轉換為金額。 class MoneyFmt(object): def __init__(self, value=0.0): self.value = float(value) def upd

C#認證考試第三章

pac png strip form ips pub 選擇背景第三章 ps：因為前面請假，沒能在規定時間做出總結，現在補上如果你看了第三章的內容，你會發現第三章在著重跟我們講解對Windows窗體的設計，其中包括窗體背景、前景色、字體顏色、位

C Primer Plus 第三章編程練習

思考 reat enter span n) 試驗 val unsigned 小數 1.通過試驗（即編寫帶有此類問題的程序）觀察系統如何處理整數上溢、浮點數上溢和浮點數下溢的情況。 #include<stdio.h> int main(void) {

第6章面向物件下

文章目錄基本資料型別的包裝類處理物件列印物件和 toString 方法 == 和 equals 比較運算子 equals() 方法的重寫類成員

《C現代程式設計》第三章 面向物件

3.2 C的模組化與面向物件

注意：

3.2.1 設定壓入範圍

引入校驗器 Validtor

實現兩種驗證器合併 ：

相關推薦

《C現代程式設計》第三章面向物件

實現兩種驗證器合併：