C Language I

2016/04/12 19:52 http://blog.naver.com/knix008/220681599809

[ Command Line (Parsing) ][ Command Line (Parsing) ]

CC

. ,

, .

. C ,

, "main()" .

"main()" "argc",

"argv" .

"-" ,

. Unix

, . , "-"

, .

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include

#include

void print_usage(void)

{

printf("=============\n");

printf("Usage:\n");

printf("CommandLineParsingExample [-x] [-y][-z]\n");

printf("=============\n");

exit(1);

}

bool xOption = false;

bool yOption = false;

bool zOption = false;

1 [ ]

http://blog.naver.com/knix008/220681599809

char xName[ 100 ] = {'\0'};

char yName[ 100 ] = {'\0'};

char zName[ 100 ] = {'\0'};

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

(Flag)

.

. , ("print_usage()");

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void parse_arguments( int argc, const char *argv[] )

{

while ((argc > 1) && (argv[1][0] == '-'))

{

switch (argv[1][1])

{

case 'x':

printf("%s\n",&argv[1][2]);

strncpy( xName, &argv[1][2], strlen(&argv[1][2]));

xOption = true;

break;

case 'y':


strncpy( yName, &argv[1][2], strlen(&argv[1][2]));

yOption = true;

break;

case 'z':


strncpy( zName, &argv[1][2], strlen(&argv[1][2]));

zOption = true;

break;

default:

printf("Wrong Argument: %s\n", argv[1]);

print_usage();

break;

}

++argv;

2 [ ]

--argc;

}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

1 . ,

.

"argv[1][0]" . ,

. "-" . , ,

("argv[1][2]"), ,

. , ("print_usage()").

, ("++argv"), ,

("-- argc").

("argv[1][0]"). .

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void print_options( void )

{

if (( xOption )||( yOption )||( zOption ))

{

printf("The Option and Name : ");

if ( xOption )

{

printf("%s ", xName );

}

if ( yOption )

{

printf("%s ", yName );

}

if ( zOption )

{

printf("%s ", zName );

}

printf("\n");

}

}

3 [ ]

int main(int argc, const char *argv[])

{

puts("Command Line Parsing Example 01"); /* prints Command Line Parsing Example 01 */

printf("Program name: %s\n", argv[0]);

parse_arguments( argc, argv );

print_options();

return EXIT_SUCCESS;

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

"main()" .

. Eclipse ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[: Eclipse ]

Command Line Parsing Example 01

Program name: /Users/shkwon/Documents/workspace/CommandLineParserExample01/Debug/

CommandLineParserExample01

[: ]

[] , Eclipse , "Project->Properties->Run/Debug Settings->"

"->Edit->Arguments Tab" .

4 [ ]


[ Template Method ][ Template Method ]

CC

. , ,

. ,

. , ,

. , , , ,

. , ,

.

, ,

. ,

.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

typedef struct algorithm ALGORITHM;

struct algorithm

{

int (*sum)( const int operand1, const int operand2 );

int (*subtract)( const int operand1, const int operand2 );

int (*multiply)( const int operand1, const int operand2 );

int (*divide)( const int operand1, const int operand2 );

};

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

. , ,

. , .

, .

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

static int sum( const int operand1, const int operand2 )

{

6 [ ]


return operand1 + operand2;

}

static int subtract( const int operand1, const int operand2 )

{

return operand1 - operand2;

}

static int multiply( const int operand1, const int operand2 )

{

return operand1 * operand2;

}

static int divide( const int operand1, const int operand2 )

{

if( operand2 == 0 )

{

printf( "Cannot calculate the result!!!\n" );

exit( 1 );

}

return operand1 / operand2;

}

ALGORITHM myAlgorithm = { sum, subtract, multiply, divide };

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

.

. , . ,

, .

, ,

.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

typedef struct template TEMPLATE;

struct template

{

ALGORITHM *algo;

7 [ ]

int ( *method )( const ALGORITHM *algo, const int operand1, const int operand2 );

};

static int calculate( const ALGORITHM *algo, const int operand1, const int operand2 )

{

return algo->sum( operand1, operand2 ) + algo->subtract( operand1, operand2 ) +

algo->multiply( operand1, operand2 ) + algo->divide( operand1, operand2 );

}

TEMPLATE myTemplate = { &myAlgorithm, calculate };

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

("algor"). ,

, ("calculate()"). ,

, , .

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main(void)

{

puts("Template Method Pattern Example 01"); /* prints Template Method Pattern Example 01 */

printf( "The calculation result : %d\n", myTemplate.method( myTemplate.algo, 1, 2 ));



printf( "The calculation result : %d\n", myTemplate.method( myTemplate.algo, 0, 0 )); /* Cannot calculate

the result!!! */


}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

.

, .

. .

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[]

Template Method Pattern Example 01

The calculation result : 4



8 [ ]

Cannot calculate the result!!!

9 [ ]


[ Proxy ][ Proxy ]

CC

(Proxy) . ,

, , .

, . , ,

, .

//////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef PROXY_H_

#define PROXY_H_

typedef struct message MESSAGE;

struct message

{

char *msg;

};

typedef struct subject SUBJECT;

typedef struct proxy PROXY;

#ifdef __cplusplus

extern "C" {

#endif

extern PROXY *getProxy( void );

extern void sendRequest( PROXY *proxy, MESSAGE *msg );

#ifdef __cplusplus

}

#endif

#endif /* PROXY_H_ */

10 [ ]


//////////////////////////////////////////////////////////////////////////////////////////////////////

#include

/* Something Missing Here!!! */

struct subject

{

char *name;

void (*handler)( SUBJECT *subject, MESSAGE *msg );

};

struct proxy

{

char *name;

SUBJECT *subject;

void (*handler)( PROXY *proxy, MESSAGE *msg );

};

static void subject_handler( SUBJECT *subject, MESSAGE *msg )

{

printf( "Subject Handler : %s, %s\n", subject->name, msg->msg );

}

static void proxy_handler( PROXY *proxy, MESSAGE *msg )

{

printf( "Proxy Handler : %s, %s\n", proxy->name, msg->msg );

proxy->subject->handler( proxy->subject, msg );

}

SUBJECT mySubject = { "My Subject", subject_handler };

PROXY myProxy = { "My Proxy", &mySubject, proxy_handler };

PROXY *getProxy( void )

{

return &myProxy;

}

11 [ ]

void sendRequest( PROXY *proxy, MESSAGE *msg )

{

proxy->handler( proxy, msg );

}

//////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include


int main(void) {

puts("Proxy Example 01"); /* prints Proxy Example 01 */

PROXY *proxy = getProxy();

MESSAGE msssage = { "Hello, World!!!" };

sendRequest( proxy, &msssage );


}

//////////////////////////////////////////////////////////////////////////////////////////////////////

[]

Proxy Example 01

Proxy Handler : My Proxy, Hello, World!!!

Subject Handler : My Subject, Hello, World!!!

12 [ ]


[ Singleton ][ Singleton ]

CC

(Singleton) . ,

.

, , .

,

. , ,

. ,

, . ,

.

//////////////////////////////////////////////////////////////////////////////////////////////

#ifndef SINGLETON_H_

#define SINGLETON_H_

typedef struct singleton SINGLETON;

#ifdef __cplusplus

extern "C" {

#endif

extern SINGLETON *create_singleton( void );

extern SINGLETON *get_Instance( SINGLETON *singleton );

extern void destroy_singleton( SINGLETON **singleton );

#ifdef __cplusplus

}

#endif

#endif /* SINGLETON_H_ */

//////////////////////////////////////////////////////////////////////////////////////////////

#include

13 [ ]


#include


struct singleton

{

SINGLETON *instance;

SINGLETON *(*getInstance)( SINGLETON *singleton );

void (*destroy)( SINGLETON **singleton );

};

SINGLETON *mySingleton = NULL;

static SINGLETON *getInstance( SINGLETON *singleton )

{

return singleton->instance;

}

static void destroySingleton( SINGLETON **singleton )

{

if ( *singleton != mySingleton )

{

printf( "Cannot destory resouces!!!\n" );

return;

}

free( mySingleton );

*singleton = NULL;

return;

}

SINGLETON *create_singleton( void )

{

if ( mySingleton != NULL )

{

return mySingleton;

}

14 [ ]

if (( mySingleton=(SINGLETON *)malloc( sizeof( SINGLETON ))) == NULL )

{

printf( "Cannot create resources!!!\n" );

return NULL;

}

mySingleton->instance = mySingleton;

mySingleton->getInstance = getInstance;

mySingleton->destroy = destroySingleton;

return mySingleton;

}

SINGLETON *get_Instance( SINGLETON *singleton )

{

return singleton->getInstance( singleton );

}

void destroy_singleton( SINGLETON **singleton )

{

if ( *singleton == NULL )

{

printf( "Cannot destroy already destroyed singleton!!!\n" );

return;

}

(*singleton)->destroy( singleton );

return;

}

//////////////////////////////////////////////////////////////////////////////////////////////

#include

#include


int main(void) {

puts("Singleton Example 01"); /* prints Singleton Example 01 */

SINGLETON *singleton = NULL;

15 [ ]

singleton = create_singleton();

singleton = create_singleton();

singleton = get_Instance( singleton );

singleton = get_Instance( singleton );

destroy_singleton( &singleton );

destroy_singleton( &singleton ); /* Cannot destroy already destroyed singleton!!! */


}

//////////////////////////////////////////////////////////////////////////////////////////////

[]

Singleton Example 01

Cannot destroy already destroyed singleton!!!

16 [ ]


[ Strategy ][ Strategy ]

CC

(Strategy) ( )

. , ,

.

.

, . ,

, ,

, .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef STRATEGY_H_

#define STRATEGY_H_

typedef enum

{

MSG_TYPE_00 = 0,

MSG_TYPE_01,

MSG_TYPE_02,

MSG_TYPE_03,

MSG_TYPE_NONE

} MSG_TYPE;

typedef struct message

{

MSG_TYPE type;

char *body;

} MESSAGE;

typedef struct strategy STRATEGY;

17 [ ]


#ifdef __cplusplus

extern "C" {

#endif

extern STRATEGY *get_strategy( void );

extern void handle_message( STRATEGY *strategy, MESSAGE *msg );

#ifdef __cplusplus

}

#endif

#endif /* STRATEGY_H_ */

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

, "struct" ,

"MESSAGE" .

, (get_strategy()).

"handle_message()" .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include "Strategy.h"

typedef void (*HANDLER)(MESSAGE *msg);

struct strategy

{

HANDLER handle[ MSG_TYPE_NONE ];

};

static void print_message_handler( MESSAGE *msg )

{

printf( "The Message Type : %d, body : %s\n", msg->type, msg->body );

}

18 [ ]

STRATEGY myStrategy = {.handle = { print_message_handler, print_message_handler,

print_message_handler, print_message_handler }};

STRATEGY *get_strategy( void )

{

return &myStrategy;

}

void handle_message( STRATEGY *strategy, MESSAGE *msg )

{

if (( msg->type < MSG_TYPE_00 )||( msg->type >= MSG_TYPE_NONE ))

{

printf("Cannot handle message!!!\n");

}

strategy->handle[ msg->type ]( msg );

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

, ("myStrategy)".

,

. , .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include "Strategy.h"

int main(void) {

puts("Strategy Pattern Example 01"); /* prints Strategy Pattern Example 01 */

MESSAGE msg00 = { MSG_TYPE_00, "This is 0th message!!!" };

MESSAGE msg01 = { MSG_TYPE_01, "This is 1st message!!!" };

MESSAGE msg02 = { MSG_TYPE_02, "This is 2nd message!!!" };

MESSAGE msg03 = { MSG_TYPE_03, "This is 3rd message!!!" };

STRATEGY *strategy = get_strategy();

19 [ ]

handle_message( strategy, &msg00 );





}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

, .

, "get_strategy()" , .

.

. , , .

, .

Strategy Pattern Example 01

The Message Type : 0, body : This is 0th message!!!

The Message Type : 1, body : This is 1st message!!!

The Message Type : 2, body : This is 2nd message!!!

The Message Type : 3, body : This is 3rd message!!!

20 [ ]


[ Composite ][ Composite ]

CC

"Composite" . ,

, .

,

.

. ,

, . ,

, . ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef COMPOSITE_H_

#define COMPOSITE_H_

typedef struct composite COMPOSITE;

typedef struct message MESSAGE;

typedef struct element ELEMENT;

struct message

{

unsigned int ID;

char *message;

};

struct element

{

unsigned int ID;

void (*do_something)( MESSAGE *msg );

};

21 [ ]


#ifdef __cplusplus

extern "C" {

#endif

extern COMPOSITE *get_composite( void );

extern void add_element( COMPOSITE *comp, ELEMENT *element );

extern void delete_element( COMPOSITE *comp, ELEMENT *element );

extern void do_something( COMPOSITE *comp, MESSAGE *msg );

#ifdef __cplusplus

}

#endif

#endif /* COMPOSITE_H_ */

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ID , (Element) ID . ID

.

("do_something()") . ,

.

("get_composite()") . ,

("do_something()").

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include "Composite.h"

#define MAX_ELEMENT 100

struct composite

{

ELEMENT *comp[ MAX_ELEMENT ];

void (*add)( COMPOSITE *comp, ELEMENT *element );

void (*delete)( COMPOSITE *comp, ELEMENT *element );

void (*do_something)(COMPOSITE *comp, MESSAGE *msg );

};

22 [ ]

static void myAdd( COMPOSITE *comp, ELEMENT *element )

{

if (( element->ID < 0 ) || ( element->ID >= MAX_ELEMENT ))

{

printf( "The element ID %d is out of range!!!\n", element->ID );

return;

}

if ( comp->comp[ element->ID ] != NULL )

{

printf( "The element ID %d is already used!!!\n", element->ID );

return;

}

comp->comp[ element->ID ] = element;

return;

}

static void myDelete( COMPOSITE *comp, ELEMENT *element )

{

if (( element->ID < 0 ) || ( element->ID >= MAX_ELEMENT ))

{

printf( "The element ID %d is out of range!!!\n", element->ID );

return;

}

if ( comp->comp[ element->ID ] == NULL )

{

printf( "The element ID %d is already unused!!!\n", element->ID );

return;

}

comp->comp[ element->ID ] = NULL;

return;

}

static void myDo_something(COMPOSITE *comp, MESSAGE *msg )

{

ELEMENT *element;

23 [ ]

for ( int i = 0; i < MAX_ELEMENT; i++ )

{

element = comp->comp[ i ];

if ( element != NULL )

{

if ( element->do_something != NULL )

{

element->do_something( msg );

}

}

}

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

ID . , NULL

. ID (Element) . ID

NULL .

, NULL ("do_something()").

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

COMPOSITE myComposite = {{ NULL }, myAdd, myDelete, myDo_something };

COMPOSITE *get_composite( void )

{

return &myComposite;

}

void add_element( COMPOSITE *comp, ELEMENT *element )

{

comp->add( comp, element );

}

void delete_element( COMPOSITE *comp, ELEMENT *element )

{

comp->delete( comp, element );

}

24 [ ]

void do_something( COMPOSITE *comp, MESSAGE *msg )

{

comp->do_something( comp, msg );

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

(Composite) . ,

. , ("get_composite()")

.

, (Delegation) .

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include "Composite.h"

void print_message( MESSAGE *msg )

{

printf("The Message : %s\n", msg->message );

}

int main(void) {

puts("Composite Example 01"); /* prints Composite Example 01 */

MESSAGE msgHelloWorld = { 1, "Hello, World!!!" };

MESSAGE msgByeWorld = { 2, "Bye, World!!!" };

ELEMENT elm01 = { 1, print_message };



COMPOSITE *myComposite = get_composite();

add_element( myComposite, &elm01 );



25 [ ]

do_something( myComposite, &msgHelloWorld );

do_something( myComposite, &msgByeWorld );

delete_element( myComposite, &elm01 );




}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

(Composite) , (Element) .

("print_message()"), .

,

. , .

, .

, .

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[]

Composite Example 01

The Message : Hello, World!!!



The Message : Bye, World!!!



26 [ ]


[ Facade ][ Facade ]

CC

"Facade" . , .

, . ,

, .

API() .

,

. , .

.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* Facade.h */

#ifndef FACADE_H_

#define FACADE_H_

typedef struct computer_information

{

char *CPU;

unsigned int GHz;

unsigned int RAM;

unsigned int HDD;

}COMPUTER_INFORMATION;

typedef struct computer COMPUTER;

struct computer

{

char *CPU;

unsigned int GHz;

unsigned int RAM;

27 [ ]


unsigned int HDD;

void (*turnOn)( COMPUTER *comp );

void (*turnOff)( COMPUTER *comp );

COMPUTER_INFORMATION *(*getInfo)( COMPUTER *comp );

};

#ifdef __cplusplus

extern "C" {

#endif

extern COMPUTER *getComputer( void );

extern void turnOnComputer( COMPUTER *comp );

extern void turnOffComputer( COMPUTER *comp );

extern COMPUTER_INFORMATION *getComputerInformation( COMPUTER *comp );

extern void print_computer_information( COMPUTER_INFORMATION *info );

#ifdef __cplusplus

}

#endif

#endif /* FACADE_H_ */

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

API .

, .

. "main()" , API

.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* Facade.c */

#include

#include "Facade.h"

28 [ ]

extern COMPUTER myComputer;

COMPUTER *getComputer( void )

{

return &myComputer;

}

void turnOnComputer( COMPUTER *comp )

{

comp->turnOn( comp );

}

void turnOffComputer( COMPUTER *comp )

{

comp->turnOff( comp );

}

COMPUTER_INFORMATION *getComputerInformation( COMPUTER *comp )

{

return comp->getInfo( comp );

}

void print_computer_information( COMPUTER_INFORMATION *info )

{

printf( "The CPU : %s\n", info->CPU );

printf( "Clock : %dGHz\n", info->GHz );

printf( "HDD : %dGByte\n", info->HDD );

printf( "RAM : %dGByte\n", info->RAM );

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

. , . ,

(Delegation) .

.

29 [ ]

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* FacadeImplementation.c */

#include

#include

#include

#include "Facade.h"

static void myTurnOn( COMPUTER *comp )

{

printf( "Computer %s is Turned On!!!\n", comp->CPU );

}

static void myTurnOff( COMPUTER *comp )

{

printf( "Computer %s is Turned Off!!!\n", comp->CPU );

}

static COMPUTER_INFORMATION *myGetInfo( COMPUTER *comp )

{

COMPUTER_INFORMATION *info = NULL;

if(( info = (COMPUTER_INFORMATION *)malloc( sizeof( COMPUTER_INFORMATION ))) == NULL )

{

printf("Cannot allocate memory for computer information!!!\n");

}

if(( info->CPU = (char *)malloc( strlen( comp->CPU ) + 1 )) == NULL )

{

printf("Cannot allocate memory for CPU information!!!\n");

}

if ( info == NULL )

{

return NULL;

}

if ( info->CPU == NULL )

30 [ ]

{

free( info );

return NULL;

}

strncpy( info->CPU, comp->CPU, strlen( comp->CPU ) + 1 );

info->GHz = comp->GHz;

info->RAM = comp->RAM;

info->HDD = comp->HDD;

return info;

}

COMPUTER myComputer = { "Intel Centrino QuadCore", 3, 8, 500, myTurnOn, myTurnOff, myGetInfo };

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

, (Implementation) .

. , ,

( ) . , .

.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* main.c */

#include

#include

#include

#include "Facade.h"

int main(void) {

puts("Facade Example 01"); /* prints Facade Example 01 */

COMPUTER *computer = getComputer();

COMPUTER_INFORMATION *info = getComputerInformation( computer );

turnOnComputer( computer );

turnOffComputer( computer );

31 [ ]

print_computer_information( info );


}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

API . API . API

"static" , .

.

.

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

[ ]

Facade Example 01

Computer Intel Centrino QuadCore is Turned On!!!

Computer Intel Centrino QuadCore is Turned Off!!!

The CPU : Intel Centrino QuadCore

Clock : 3GHz

HDD : 500GByte

RAM : 8GByte

32 [ ]


[ Chain of Responsibility ][ Chain of Responsibility ]

CC

"Chain of Responsibility" . ,

, ,

. , .

(Chain) .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include


{

unsigned int ID;

char msg[ 100 ];

} MESSAGE;

typedef struct chain CHAIN;

struct chain

{

unsigned int ID;

char *name;

CHAIN *next;

bool (*do_somthing)( CHAIN *target, MESSAGE *msg );

};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

. ()

, (do_something()).

33 [ ]


, ID ID . ,

( ) "next" .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool myHandler( CHAIN *target, MESSAGE *msg )

{

if ( target->ID == msg->ID )

{

printf( "Message Handler Name : %s, Message : %s\n", target->name, msg->msg );

return true;

}

return false;

}

CHAIN handler1 = { 1, "1st Handler", NULL, myHandler };

CHAIN handler2 = { 2, "2nd Handler", &handler1, myHandler };

CHAIN handler3 = { 3, "3rd Handler", &handler2, myHandler };

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

,

. ,

. "3->2->1" . ,

. , ,

, .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

bool sendMessage( CHAIN *target, MESSAGE *msg )

{

while( target )

{

if( target->do_somthing( target, msg ))

{

break;

}

target = target->next;

34 [ ]

}

if ( target == NULL )

{

printf( "Cannot handle the message : %d, %s\n", msg->ID, msg->msg );

return false;

}

return true;

}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

. , , "true"

. , , .

"false" . , .

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

int main(void)

{

MESSAGE message1 = { 1, "This Message is for the First!!!" };

MESSAGE message2 = { 2, "This Message is for the Second!!!" };

MESSAGE message3 = { 3, "This Message is for the Third!!!" };

puts("Chain of Responsibility Example 01"); /* prints Chain of Responsibility Example 01 */

sendMessage( &handler3, &message1 );




}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

. "sendMessage()" . .

35 [ ]

Chain of Responsibility Example 01

Message Handler Name : 1st Handler, Message : This Message is for the First!!!

Message Handler Name : 2nd Handler, Message : This Message is for the Second!!!

Message Handler Name : 3rd Handler, Message : This Message is for the Third!!!

36 [ ]


[ Decorator ][ Decorator ]

CC

(Decorator) .

, , ,

, . ,

(Header) (Tail) . ,

, , .

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include

typedef struct Message

{

char message[100];

} MESSAGE;

typedef struct Decorator DECORATOR;

struct Decorator

{

char *decorator_name;

DECORATOR *next_decorator;

void (*do_something)(MESSAGE *msg);

};

void do_something_method(MESSAGE *msg)

{

37 [ ]


printf("Message : %s\n", msg->message);

strcat(msg->message, "More!!!");

return;

}

DECORATOR myThirdDecorator = { "Third Decorator", NULL, do_something_method };

DECORATOR mySecondDecorator = { "Second Decorator", &myThirdDecorator, do_something_method };

DECORATOR myFirstDecorator = { "First Decorator", &mySecondDecorator, do_something_method };

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

. "struct"

. , ,

.

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void do_decorator(DECORATOR *deco, MESSAGE *msg)

{

do

{

deco->do_something( msg );

deco = deco->next_decorator;

}while(deco != NULL);

}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

, . ,

"struct" ,

. , , .

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

38 [ ]

int main(void)

{

puts("Decorator Example 01");

MESSAGE msg = { "Let's enjoy!!!" };

do_decorator(&myFirstDecorator, &msg);


}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////

API . ,

, API .

. .

.

, .

Decorator Example 01

Message : Let's enjoy!!!

Message : Let's enjoy!!!More!!!

Message : Let's enjoy!!!More!!!More!!!

39 [ ]


[ Factory "switch()" ][ Factory "switch()" ]

CC

"switch()" , ,

. , "swich()" ,

"swich()" . "switch()"

. , "( )"

. "switch()"

"(Factory) .

"" . ,

, ,

(Delegation). , "switch()" .

, , "switch()" .

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef FACTORYINTERFACE_H_

#define FACTORYINTERFACE_H_

typedef enum

{

MODEL_X = 0,

MODEL_Y,

MODEL_Z,

MODEL_NONE

} MODEL_TYPE;

typedef struct product_handle PRODUCT_HANDLE;

#ifdef __cplusplus

extern "C" {

40 [ ]


#endif

extern MODEL_TYPE get_model_type( PRODUCT_HANDLE *handle );

extern void print_model_name( PRODUCT_HANDLE *handle );

extern PRODUCT_HANDLE *create_product_model( MODEL_TYPE );

#ifdef __cplusplus

}

#endif

#endif /* FACTORYINTERFACE_H_ */

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

.

, ("print_model_name()"),

("create_product_model()") .

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include "FactoryInterface.h"

struct product_handle

{

MODEL_TYPE model_type;

char *model_name;

MODEL_TYPE (*get_model_type)( void );

void (*print_model_name)( PRODUCT_HANDLE *handle );

};

static MODEL_TYPE model_x_get_type( void )

{

return MODEL_X;

}

41 [ ]

static MODEL_TYPE model_y_get_type( void )

{

return MODEL_Y;

}

static MODEL_TYPE model_z_get_type( void )

{

return MODEL_Z;

}

static MODEL_TYPE model_none_get_type( void )

{

return MODEL_NONE;

}

static void print_each_model_name( PRODUCT_HANDLE *handle )

{

printf( "The Model Name : %s\n", handle->model_name );

}

static void print_model_name_none( PRODUCT_HANDLE *handle )

{

printf("Nothing to print!!!\n");

}

MODEL_TYPE get_model_type( PRODUCT_HANDLE *handle )

{

return handle->get_model_type();

}

void print_model_name( PRODUCT_HANDLE *handle )

{

handle->print_model_name( handle );

}

42 [ ]

PRODUCT_HANDLE model_x = { MODEL_X, "Model X", model_x_get_type, print_each_model_name };

PRODUCT_HANDLE model_y = { MODEL_Y, "Model Y", model_y_get_type, print_each_model_name };

PRODUCT_HANDLE model_z = { MODEL_Z, "Model Z", model_z_get_type, print_each_model_name };

PRODUCT_HANDLE model_none = { MODEL_NONE, "Model None", model_none_get_type,

print_model_name_none };

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

3 , "Null" . ,

, .

. .

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

PRODUCT_HANDLE *create_product_model( MODEL_TYPE model_type )

{

switch( model_type )

{

case MODEL_X:

return &model_x;

break;

case MODEL_Y:

return &model_y;

break;

case MODEL_Z:

return &model_z;

break;

default:

printf("Cannot create your model!!!\n");

return &model_none;

break;

}

}

43 [ ]

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

. "struct"

, "struct" . "switch()"

, "switch()" . , ,

, .

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include "FactoryInterface.h"

int main(void)

{

PRODUCT_HANDLE *product;

puts("Switch Removal Example 01"); /* prints Switch Removal Example 01 */

product = create_product_model( MODEL_X );

print_model_name( product );

product = create_product_model( MODEL_Y );


product = create_product_model( MODEL_Z );


product = create_product_model( MODEL_NONE );



}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

44 [ ]

, . ,

. ,

. , ,

. , .

, . . .

Switch Removal Example 01

The Model Name : Model X

The Model Name : Model Y

The Model Name : Model Z

Cannot create your model!!!

Nothing to print!!!

45 [ ]


[ ][ ]

CC

. ,

. " ".

, . , ,

. , , .

, ,

, . .

.

01. .

02. .

03. .

04. .

05. .

06. .

07. .

08. .

09. .

10. .

46 [ ]


10 , . ,

. ,

. ( ) ,

. , .

, . ,

, .

47 [ ]


[ "#pragma once" ][ "#pragma once" ]

CC

C "#include" , (, )

. .

#ifndef __XXX_H__

#define __XXX_H__

...

#endif

, "#pragma once" . GCC Micosoft C/C++

"#pragma once" , . ,

, "#pragma once" .

, , ,

.

/////////////////////////////////////////////////////////////////////

/* myHeader.h */

//#ifndef MYHEADER_H_ /* #pragma once */

//#define MYHEADER_H_

//#endif /* MYHEADER_H_ */

#pragma once

extern void print_hello_world( void );

/////////////////////////////////////////////////////////////////////

/* myHeader.c */

48 [ ]


#include

#include "myHeader.h"

void print_hello_world( void )

{

printf("Hello, World!!!\n");

return;

}

/////////////////////////////////////////////////////////////////////

/* main.c */

#include

#include

#include "myHeader.h"

int main(void) {

puts("Header File Include Example 01");

print_hello_world();


}

/////////////////////////////////////////////////////////////////////

49 [ ]


[ (?) ][ (?) ]

CC

. ,

. , .

. .

, . ,

, . ,

.

. , (Test)

. . ,

, 10~20 . ,

. 5~10 .

, , .

.

. . ,

. ,

, . , (Test) (Review) .

. ,

. .

.

. C (Unit) .

. , , .

, TDD(Test Driven Development) .

, . ("{ }"

) , . , . ,

.

50 [ ]


.

, . , .

, , . ,

, ,

. , (Debugger)

. , .

, ( ) .

. . ,

.

(Spaghetti Code) .

. , .

, ,

. , ,

.

.

, .

. .

, . ,

, .

. .

.

, , . C

, ? C

51 [ ]

C ? " " .

. ,

.

, .

, , .

, , , ->->

-> . . ,

, .

, . ,

. , , ,

. .

. , .

,

. , , .

, . ,

. , .

(MIlestone) .

, .

. , 100%

. . 90%

. , 90% , .

, 90%, 10%

. , .

"All-or-Nothing" . % . ,

% . , .

,

. ,

. ,

. , ,

.

, .

52 [ ]

, , .

, .

[ : Software Project Survival Guide - Steve McConnel ]

53 [ ]


[ Reflection ][ Reflection ]

CC

"Reflection" (Structure) (Behavior) ,

(Ability) . Java .Net ,

. C ,

.

//////////////////////////////////////////////////////////////////////////////////////

#ifndef REFLECTOR_H_

#define REFLECTOR_H_

typedef struct reflector REFLECTOR;

struct reflector {

char name[100];

unsigned int age;

bool married;

REFLECTOR *(*set_name)(REFLECTOR *info, const char *name);

REFLECTOR *(*set_age)(REFLECTOR *info, const unsigned int age);

REFLECTOR *(*set_marrital_status)(REFLECTOR *info, const bool married);

REFLECTOR *(*get_name)(REFLECTOR *info, char **name);

REFLECTOR *(*get_age)(REFLECTOR *info, unsigned int *age);

REFLECTOR *(*get_marrital_status)(REFLECTOR *info, bool *married);

};

extern REFLECTOR personal_info;

#ifdef __cplusplus

extern "C" {

#endif

54 [ ]


extern void print_personal_info(REFLECTOR *info);

#ifdef __cplusplus

}

#endif

#endif /* REFLECTOR_H_ */

//////////////////////////////////////////////////////////////////////////////////////

"struct"

. ,

. , " main.c"

.

//////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include

#include

#include "Reflector.h"

static REFLECTOR *set_name(REFLECTOR *info, const char *name) {

strncpy(info->name, name, strlen(name) + 1);

return info;

}

static REFLECTOR *set_age(REFLECTOR *info, const unsigned int age) {

info->age = age;

return info;

}

55 [ ]

static REFLECTOR *set_marrital_status(REFLECTOR *info, const bool married) {

info->married = married;

return info;

}

static REFLECTOR *get_name(REFLECTOR *info, char **name) {

if ((*name = (char *) malloc(strlen(info->name) + 1)) == NULL) {

printf("Cannot allocated memory!!!\n");

return info;

}

strncpy(*name, info->name, strlen(info->name) + 1);

return info;

}

static REFLECTOR *get_age(REFLECTOR *info, unsigned int *age) {

*age = info->age;

return info;

}

static REFLECTOR *get_marrital_status(REFLECTOR *info, bool *married) {

*married = info->married;

return info;

}

//////////////////////////////////////////////////////////////////////////////////////

REFLECTOR personal_info = {

.set_name = set_name,

.set_age = set_age,

.set_marrital_status = set_marrital_status,

.get_name = get_name,

.get_age = get_age,

.get_marrital_status = get_marrital_status

};

//////////////////////////////////////////////////////////////////////////////////////

56 [ ]

"struct" C99 . ,

. ,

.

//////////////////////////////////////////////////////////////////////////////////////

void print_personal_info(REFLECTOR *info)

{

printf("========================\n");

printf("Name : %s\n", info->name);

printf("Age : %d\n", info->age);

printf("Married : %s\n", (info->married) ? "Married" : "Not Married");

printf("========================\n");

}

//////////////////////////////////////////////////////////////////////////////////////

(Accessor) "get, set" .

. "Call-by-Reference"

"**" ("get_name()"). ,

.

//////////////////////////////////////////////////////////////////////////////////////

#include

#include

#include

#include

#include "Reflector.h"

void print_information(const char *name, const unsigned int age, const bool married) {

printf("========================\n");

printf("Name : %s\n", name);

57 [ ]

printf("Age : %d\n", age);

printf("Married : %s\n", (married) ? "Married" : "Not Married");

printf("========================\n");

}

int main(void) {

puts("ReflectionExample 01"); /* prints ReflectionExample 01 */

(((personal_info.set_name(&personal_info, "SH Kwon"))->set_age(

&personal_info, 44))->set_marrital_status(&personal_info, true));

print_personal_info(&personal_info);

char *name = NULL;

unsigned int age = 0;

bool married = false;

(((personal_info.get_name(&personal_info, &name))->

get_age(&personal_info, &age))->get_marrital_status(&personal_info, &married));

print_information(name, age, married);


}

//////////////////////////////////////////////////////////////////////////////////////

,

. C ,

. ,

. .

58 [ ]

,

. , Reflection

.

59 [ ]


[ (File) (Directory) ][ (File) (Directory) ]

CC

. C

".C" . ,

, (Build) , ,

. "Copyright" , ,

. (Template) .

"Readme" "Install", "ReleaseNote" , .

. , .

.

. (Editor) ,

, .

.

.

. , "NET_" .

. "NET_SOCKET_CONNECT.c"

, "socket" .

. Unix

. "_" . ,

. ,

. .

.

. , . ,

. , (Script) .

, (Subsystem)

. , .

60 [ ]


, .

. "Include"

. , "Include"

. , .

, . ,

, .

, "-> -> -> -> "

. ,

(Clean) . ,

. , .

. " (Naming Rule)"

. .

61 [ ]


[ (Function) ][ (Function) ]

CC

C . ,

. "y=f(x)" , "f()"

, "y" . , "f(x)" .

.

, .

, .

(Contract) , .

, . ,

( .).

,

. , ,

. , ,

.

char *MM_Allocate_Buffer( const size_t size );

, MM(Memory Manager) .

, .

, "const" . ,

. , .

"Doxygen" ,

, .

. . ,

.

.

62 [ ]


/*****************************************************************

* @name MM_Allocate_Buffer( const size_t size )

* @description This function will allocate one buffer specified in size

* @param size The size of the buffer in bytes which is allocated

* @return The allocated buffer address pointer

*/

char *MM_Allocate_Buffer( const size_t size );

"Doxygen" . Doxygen ,

. ,

. , ,

.

. .

, .

, . ,

, .

4 (

).

TEST_ASSERT_EQUAL( NULL, MM_Allocate_Buffer( 0 ));

TEST_ASSERT_NOT_EQUAL( NULL, MM_Allocate_Buffer( 2 ));

...

. , . ,

. "xxx_and_yyy" ,

. , .

. , .

100 . ,

.

. , ,

, . , .

(Cycle)

63 [ ]

. , . ,

, .

. ,

. ,

. ,

. , ,

. ,

.

char *MM_Allocate_Buffer( size_t size )

{

if ( size == 0 )

{

return NULL;

}

return (char*)malloc( size );

}

.

. , CPU .

, .

. .

. ,

. (Entry Point)

, (Exit Point) . ,

(return ) . (Plat)

. (While Box) .

.

64 [ ]


[ (Variable) ][ (Variable) ]

CC

. ,

(Type) . , .

, . ,

, ,

.

, , . .

,

. ,

. ,

.

. ,

. ,

.

int temp1, temp2;

. , ,

. "temp" ,

. , . ,

"old_age" . , ,

.

, "for()" "i, j, k" .

. ,

. ,

.

65 [ ]


, . "Magic Number"

. .

. ,

.

int x = 256;

...

if ( k != 256 )

{

...

}

, "256" . ,

, , . ,

, . , "#define MAX_NAME_SIZE 256" ,

"MAX_NAME_SIZE" ,

.

. ,

. , .

. C , "C99"

. , .

...

for( int i; i < MAX_NAME_SIZE; i++ )

{

}

'for()" , i "for()" . , "for()"

. , . , .

, , .

. , . , ,

. , . ,

66 [ ]

(, )

. ,

.

? .

. ,

, .

char *gpzName = "My Name";

"g" (Global) , "pz" "Zero "

. , ? . , "char *name" ,

. , "gpz"

. .

, . ,

(Overhead) . , .

, , CPU

. .

. ,

. . , . ,

.

. ,

.

. , ,

.

, . ,

. .

(, )

. , . ,

. ,

. , .

67 [ ]

. ,

.

68 [ ]


[ (Adapter) ][ (Adapter) ]

CC

,

. , ,

. 3rd Party API ,

. , ,

.

DataBase , API ,

. ,

,

. , , ,

3 .

, ,

. ,

3 . , , 2 . ,

,

.

//////////////////////////////////////////////////////////////////

#include

#include

#include

int main(void)

{

char *test_string = "0123456789";

char result_string_without_zero[100];

char result_string_with_zero[100];

69 [ ]


memset( result_string_without_zero, 0, sizeof( char ));

memset( result_string_with_zero, 0, sizeof( char ));

printf("The length of string : %d\n", strlen( test_string ));

strncpy( result_string_without_zero, test_string, strlen( test_string ));

strncpy( result_string_with_zero, test_string, strlen( test_string ) + 1 );

printf( "The result string : %s\n", result_string_without_zero );

printf( "The result string : %s\n", result_string_with_zero );


}

//////////////////////////////////////////////////////////////////

[]

The length of string : 10

The result string : 0123456789?v

The result string : 0123456789

"strlen()" . , "strlen()" string

. "strlen()"

"\0"(Terminating Null) . , "strlen()"

"1" .

, "strlen()"

. , .

//////////////////////////////////////////////////////////////////

#include

#include

#include

unsigned int mystrlen( char *str )

{

unsigned int str_length = strlen( str ) + 1;

return str_length;

}

70 [ ]

int main(void)

{


char result_string_without_zero[100];

char result_string_with_zero[100];

memset( result_string_without_zero, 0, sizeof( char ));

memset( result_string_with_zero, 0, sizeof( char ));

printf("The length of string : %d\n", strlen( test_string ));

strncpy( result_string_without_zero, test_string, strlen( test_string ));

strncpy( result_string_with_zero, test_string, strlen( test_string ) + 1 );



printf( "\nUsing Adapter Pattern!!!\n");

strncpy( result_string_without_zero, test_string, mystrlen( test_string ));

strncpy( result_string_with_zero, test_string, mystrlen( test_string ) + 1 );




}

//////////////////////////////////////////////////////////////////

, "strlen()" ("mystrlen()")

. , , API

. API ,

.

, .

(Wrapping) . "strcpy()" "\0"

, .

71 [ ]

//////////////////////////////////////////////////////////////////

/* MyString.h */

#ifndef MYSTRING_H_

#define MYSTRING_H_

#ifdef __cplusplus

extern "C" {

#endif

extern unsigned int mystrlen( const char *str );

extern char *mystrcpy( char *destination,const char* source);

#ifdef __cplusplus

}

#endif

#endif /* MYSTRING_H_ */

//////////////////////////////////////////////////////////////////

/* MyString.c */

#include

unsigned int mystrlen(const char *str)

{

unsigned int length = strlen(str) + 1;

if (str == NULL)

{

return 0;

}

return length;

}

char *mystrcpy(char *destination, const char* source)

{

return strncpy(destination, source, strlen(source) + 1);

72 [ ]

}

//////////////////////////////////////////////////////////////////

/* main.c */

#include

#include

#include

#include "MyString.h"

int main(void)

{


char result_string[100];

printf("\nUsing Adapter Pattern Example 02!!!\n");

printf("The string Length : %d\n", mystrlen(test_string));

printf("The Copyied string : %s\n", mystrcpy(result_string, test_string));


}

//////////////////////////////////////////////////////////////////

[ ]

Using Adapter Pattern Example 02!!!

The string Length : 11

The Copyied string : 0123456789

, "+1" "\0"

. API

, .

.

73 [ ]


[ : State Pattern - 03 ][ : State Pattern - 03 ]

CC

,

. , ,

. ,

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef STATEMACHINE_H_

#define STATEMACHINE_H_

typedef struct StateMachine STATE_MACHINE;

typedef enum

{

STATE_INIT = 0,

STATE_READY,

STATE_RUNNING,

STATE_WAITING,

STATE_STOPPED,

STATE_NONE

} STATE;

typedef enum

{

EVENT_PRINT = 0,

EVENT_NEXT,

EVENT_PREVIOUS,

EVENT_EXIT,

EVENT_NONE

} EVENT;

74 [ ]



{

char *msg;

} MESSAGE;

#ifdef __cplusplus

extern "C" {

#endif

extern void init_state_machine( void );

extern void run_state_machine( void );

#ifdef __cplusplus

}

#endif

#endif /* STATEMACHINE_H_ */

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

("STATE_MACHINE"), ("STATE"),

("EVENT") . , ("MESSAGE")

. ,

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include "StateMachine.h"

typedef void (*HANDLER)( char *state, MESSAGE *msg );

struct StateMachine

{

char *name;

HANDLER handler[ EVENT_NONE ];

};

static void event_print_message( char *state, MESSAGE *msg )

75 [ ]

{

printf( "%s : Print Handler Called : %s!!!\n", state, msg->msg );

}

static void event_next_message( char *state, MESSAGE *msg )

{

printf( "%s : Next Handler Called : %s!!!\n", state, msg->msg );

}

static void event_previous_message( char *state, MESSAGE *msg )

{

printf( "%s : Previous Handler Called : %s!!!\n", state, msg->msg );

}

static void event_exit_message( char *state, MESSAGE *msg )

{

printf( "%s : Exit Handler Called : %s!!!\n", state, msg->msg );

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

("name") ("handler[]") .

, . ,

, . ,

, ,

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* */

STATE_MACHINE init = { "Init", { event_print_message, event_next_message, event_previous_message,

event_exit_message }};

STATE_MACHINE ready = { "Ready", { event_print_message, event_next_message,

event_previous_message, event_exit_message }};

STATE_MACHINE running = { "Running", { event_print_message, event_next_message,


STATE_MACHINE waiting = { "Waiting", { event_print_message, event_next_message,


76 [ ]

STATE_MACHINE stopped = { "Stopped", { event_print_message, event_next_message,


STATE_MACHINE *state_machine[ STATE_NONE ] = { &init, &ready, &running, &waiting, &stopped };

static STATE currentState = STATE_NONE;

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

.

. , ,

. "currentState" .

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* */

MESSAGE init_msg = { "Print Message" };

MESSAGE next_msg = { "Next Message" };

MESSAGE previous_msg = { "Previous Message" };

MESSAGE exit_msg = { "Exit Message" };

static void handle_state_machine( EVENT event, MESSAGE *msg )

{

STATE_MACHINE *state;

state = state_machine[ currentState ];

state->handler[ event ]( state->name, msg );

}

void init_state_machine( void )

{

currentState = STATE_INIT;

}

void run_state_machine( void )

{

77 [ ]

while( currentState != STATE_NONE )

{

handle_state_machine( EVENT_PRINT, &init_msg );

handle_state_machine( EVENT_NEXT, &next_msg );

handle_state_machine( EVENT_PREVIOUS, &previous_msg );

handle_state_machine( EVENT_EXIT, &exit_msg );

currentState++;

}

}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

,

. .

"handle_state_machine()" .

, . ,

, . ,

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include


int main(void) {

puts("State Pattern Example 03");

init_state_machine();

run_state_machine();


}

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

"main()" ,

. , ,

. ,

78 [ ]

. ,

.

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

State Pattern Example 03

Init : Print Handler Called : Print Message!!!

Init : Next Handler Called : Next Message!!!

Init : Previous Handler Called : Previous Message!!!

Init : Exit Handler Called : Exit Message!!!

Ready : Print Handler Called : Print Message!!!

Ready : Next Handler Called : Next Message!!!

Ready : Previous Handler Called : Previous Message!!!

Ready : Exit Handler Called : Exit Message!!!

Running : Print Handler Called : Print Message!!!

Running : Next Handler Called : Next Message!!!

Running : Previous Handler Called : Previous Message!!!

Running : Exit Handler Called : Exit Message!!!

Waiting : Print Handler Called : Print Message!!!

Waiting : Next Handler Called : Next Message!!!

Waiting : Previous Handler Called : Previous Message!!!

Waiting : Exit Handler Called : Exit Message!!!

Stopped : Print Handler Called : Print Message!!!

Stopped : Next Handler Called : Next Message!!!

Stopped : Previous Handler Called : Previous Message!!!

Stopped : Exit Handler Called : Exit Message!!!

///////////////////////////////////////////////////////////////////////////////////////////////////////////////

.

, . ,

, . ,

. ,

.

79 [ ]


[ ][ ]

CC

" " . ""

, . ,

.

. , .

, .

, . ,

. , .

,

. . ,

.

. .

. . , .

, . ,

. .

.

. , .

, . ,

. , .

, . ,

. .

. ,

. , .

,

. , .

80 [ ]


. ,

.

81 [ ]



CC

, (State) ,

(do_something()). , ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#ifndef STATEMACHINE_H_

#define STATEMACHINE_H_

typedef struct state_machine STATE_MACHINE;

typedef enum

{

INIT_STATE = 0,

READY_STATE,

RUNNING_STATE,

WAIT_STATE,

STOP_STATE,

NONE_STATE

} MACHINE_STATE;

#ifdef __cplusplus

extern "C" {

#endif

STATE_MACHINE *init_state_machine( void );

void run_state_machine( STATE_MACHINE *state );

#ifdef __cplusplus

}

82 [ ]


#endif

#endif /* STATEMACHINE_H_ */

. ("NONE_STATE") ,

. ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include


struct state_machine

{

MACHINE_STATE state;

void (*do_something)( STATE_MACHINE *state );

};

static void print_current_state( STATE_MACHINE *state )

{

printf("The Current Machine State : ");

switch( state->state )

{

case INIT_STATE:

printf("Init State!!!\n");

state->state = READY_STATE;

break;

case READY_STATE:

printf("Ready State!!!\n");

state->state = RUNNING_STATE;

break;

case RUNNING_STATE:

printf("Running State!!!\n");

state->state = WAIT_STATE;

83 [ ]

break;

case WAIT_STATE:

printf("Wait State!!!\n");

state->state = STOP_STATE;

break;

case STOP_STATE:

printf("Stop State!!!\n");

state->state = NONE_STATE;

break;

default :

printf("Cannot Determine Current State!!!\n");

break;

}

}

. ,

, (Handler Function)

. .

, . ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* */

STATE_MACHINE machine_init = { INIT_STATE, print_current_state };

STATE_MACHINE machine_ready = { READY_STATE, print_current_state };

STATE_MACHINE machine_running = { RUNNING_STATE, print_current_state };

STATE_MACHINE machine_wait = { WAIT_STATE, print_current_state };

STATE_MACHINE machine_stop = { STOP_STATE, print_current_state };

STATE_MACHINE machine_none = { NONE_STATE, print_current_state };

(Action) .

(Type) , . , ,

.

, , ,

. , "print_current_state()" ,

84 [ ]

. , ,

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* */

static STATE_MACHINE *do_state_machine( STATE_MACHINE *state )

{

STATE_MACHINE *newState = NULL;

switch( state->state )

{

case INIT_STATE:

newState = &machine_ready;

break;

case READY_STATE:

newState = &machine_running;

break;

case RUNNING_STATE:

newState = &machine_wait;

break;

case WAIT_STATE:

newState = &machine_stop;

break;

case STOP_STATE:

newState = &machine_none;

break;

default :

printf("Cannot Determine Current State!!!\n");

break;

}

state->do_something( state );

return newState;

}

85 [ ]

. ,

("state->do_something()"). , ,

.

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* */

STATE_MACHINE *init_state_machine( void )

{

return &machine_init;

}

void run_state_machine( STATE_MACHINE *state )

{

STATE_MACHINE *machine;

/* Run the state machine here */

do

{

machine = do_state_machine( state );

}while( machine != NULL );

}

, . ,

, .

, (Power Off)

.

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

#include

#include


86 [ ]

int main(void) {

puts("State Pattern Example 02"); /* prints State Pattern Example 02 */

STATE_MACHINE *state;

state = init_state_machine();

run_state_machine( state );


}

, .

.

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////


The Current Machine State : Init State!!!

The Current Machine State : Ready State!!!

The Current Machine State : Running State!!!

The Current Machine State : Wait State!!!

The Current Machine State : Stop State!!!

Cannot Determine Current State!!!

The Current Machine State : Cannot Determine Current State!!!

. ,

, ,

, , .

,

.

87 [ ]



CC

.

, , . ,

. (Finite State)

(Machine) . ,

, .

In State A : Event X : Do Somthing : Next State

, Event X , State A ,

(Do Something), . ,

, . Event X

(Handler) , ,

API . , Event X ,

.

,

. , Compiler , (Parsing)

,

. UI ,

( ) ,

. , , (Default)

.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* StatePattern.h */

#ifndef STATEPATTERN_H_

#define STATEPATTERN_H_

typedef enum

88 [ ]


{

INIT_STATE = 0,

READY_STATE,

RUNNING_STATE,

SLEEP_STATE,

STOP_STATE,

NONE

} STATE;

typedef struct StatePattern STATE_PATTERN;

#ifdef __cplusplus

extern "C" {

#endif

extern STATE_PATTERN *init_state_machine( void );

extern void run_state_machine( STATE_PATTERN *state );

#ifdef __cplusplus

}

#endif

#endif /* STATEPATTERN_H_ */

,

"struct" .

, 2 .

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* StatePattern.c */

#include

#include "StatePattern.h"

struct StatePattern

{

STATE currentState;

89 [ ]

void (*do_action)( STATE_PATTERN *state );

};

static void init( STATE_PATTERN *state );

static void ready( STATE_PATTERN *state );

static void running( STATE_PATTERN *state );

static void sleep( STATE_PATTERN *state );

static void stop( STATE_PATTERN *state );

static void init( STATE_PATTERN *state )

{

printf("The current state is : INIT!!!\n");

state->currentState = READY_STATE;

state->do_action = ready;

}

static void ready( STATE_PATTERN *state )

{

printf("The current state is : READY!!!\n");

state->currentState = RUNNING_STATE;

state->do_action = running;

}

static void running( STATE_PATTERN *state )

{

printf("The current state is : RUNNING!!!\n");

state->currentState = SLEEP_STATE;

state->do_action = sleep;

}

static void sleep( STATE_PATTERN *state )

{

printf("The current state is : SLEEP!!!\n");

state->currentState = STOP_STATE;

state->do_action = stop;

90 [ ]

}

static void stop( STATE_PATTERN *state )

{

printf("The current state is : STOP!!!\n");

state->currentState = NONE;

state->do_action = init;

}

static STATE_PATTERN machine;

STATE_PATTERN *init_state_machine( void )

{

machine.currentState = INIT_STATE;

machine.do_action = init;

return &machine;

}

void run_state_machine( STATE_PATTERN *state )

{

do

{

state->do_action( state );

}while ( state->currentState != NONE );

}

.

, , .

. ,

, . ,

.

"run_state_machine()" .

. ,

91 [ ]

.

.

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* Main.c */

#include

#include

#include "StatePattern.h"

int main(void)

{

puts("State Pattern Example 01"); /* prints State Pattern Example 01 */

STATE_PATTERN *machine = init_state_machine();

run_state_machine( machine );


}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

"main()" , ("run_state_machine()") .

, .

, , "main()"

.

[ : ]


The current state is : INIT!!!

The current state is : READY!!!

The current state is : RUNNING!!!

The current state is : SLEEP!!!

The current state is : STOP!!!

92 [ ]


[ : NULL Object [ : NULL Object ]]

CC

,

"Null" .

, "Null"

. , , "Null' .

, "Null" ,

. "Null Object" ,

. , "Default" , "Null"

.

#include

#include

#include

#include

typedef struct Personal_Information PERSONAL_INFORMATION;

struct Personal_Information

{

char *name;

unsigned int age;

bool married;

void ( *print_personal_information )( PERSONAL_INFORMATION *info );

};

(Handler) ,

. , ,

.

93 [ ]


. ,

.

void my_print_personal_information( PERSONAL_INFORMATION *info )

{

printf( "Name : %s\n", info->name );

printf( "Age : %d\n", info->age );

printf( "Married : %s\n", (( info->married ) ? ("Yes") : ("No")));

}

void null_print_personal_information( PERSONAL_INFORMATION *info )

{

/* Nothing to do */

printf( "Null Information!!!\n");

}

PERSONAL_INFORMATION NullInfo = { "No Name", 0, false, null_print_personal_information };

"Null Object" (Type) .

("null_print_personal_information()). NULL "Null

Object" .

PERSONAL_INFORMATION *allocate_structure( const char *name, const int age, const bool married )

{

PERSONAL_INFORMATION *tempInfo;

/* Allocate required memory */

if (( tempInfo = (PERSONAL_INFORMATION *)malloc( sizeof( PERSONAL_INFORMATION ))) == NULL )

{

printf("Cannot allocate required memory : error 01!!!");

return &NullInfo;

}

if (( tempInfo->name = (char*)malloc( strlen( name ) + 1 )) == NULL )

{

printf("Cannot allocate requireed memory : error 02!!!");

94 [ ]

free( tempInfo );

return &NullInfo;

}

strncpy( tempInfo->name, name, strlen( name ) + 1 );

tempInfo->age = age;

tempInfo->married = married;

tempInfo->print_personal_information = my_print_personal_information;

return tempInfo;

//return &NullInfo;

}

.

,

. , "Null Object"

. , "Null Object" , "//" , "//"

.

int main(void)

{

puts("Null Object Test 01");

puts("===================");

PERSONAL_INFORMATION *myinfo;

/* Allocate structure */

myinfo = allocate_structure( "SH Kwon", 44, true );

/* Print information */

myinfo->print_personal_information( myinfo );

puts("===================");


}

"allocate_structure()" . , "Null

Object" , "Null" .

, , .

95 [ ]

"Null Object"

, , .

(Default)

, ( Binary Image

). , ,

(interface) .

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* main.c */

#include

#include

#include

#include

#include "PersonalInformation.h"

int main(void)

{

puts("Null Object Test 01");

puts("===================");

PERSONAL_INFORMATION *myinfo;

/* Allocate structure */

myinfo = allocate_information_structure("SH Kwon", 44, true);

/* Print information */

print_information(myinfo);

puts("===================");


}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* PersonalInformation.h */

#ifndef PERSONALINFORMATION_H_

#define PERSONALINFORMATION_H_

96 [ ]

typedef struct Personal_Information PERSONAL_INFORMATION;

#ifdef __cplusplus

extern "C"{

#endif

extern PERSONAL_INFORMATION *allocate_information_structure(const char *name, const int age, const

bool married);

extern void print_information( PERSONAL_INFORMATION *info );

#ifdef __cplusplus

}

#endif

#endif /* PERSONALINFORMATION_H_ */

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/* personalInformation.c */

#include

#include

#include

#include

#include "PersonalInformation.h"

struct Personal_Information

{

char *name;

unsigned int age;

bool married;

void (*print_personal_information)(PERSONAL_INFORMATION *info);

};

static void my_print_personal_information(PERSONAL_INFORMATION *info)

{

printf("Name : %s\n", info->name);

97 [ ]

printf("Age : %d\n", info->age);

printf("Married : %s\n", ((info->married) ? ("Yes") : ("No")));

}

static void null_print_personal_information(PERSONAL_INFORMATION *info)

{

/* Nothing to do */

printf("Null Information!!!\n");

}

PERSONAL_INFORMATION NullInfo =

{ "No Name", 0, false, null_print_personal_information };

PERSONAL_INFORMATION *allocate_information_structure(const char *name, const int age,

const bool married)

{

PERSONAL_INFORMATION *tempInfo;

/* Allocate required memory */

if ((tempInfo = (PERSONAL_INFORMATION *) malloc(sizeof(PERSONAL_INFORMATION))) == NULL)

{

printf("Cannot allocate required memory : error 01!!!");

return &NullInfo;

}

if ((tempInfo->name = (char*) malloc(strlen(name) + 1)) == NULL)

{

printf("Cannot allocate requireed