C로 C++ 흉내내기?

딴지일지 모릅니다만..
머하러 어렵게 C로 C++ 흉내냅니까... 그냥 C++ 사용하면되지..
C++ 흉내냈다고 해봤자 C++ 같지도 않구요..
C로는 그냥 C 처럼 짜는것이 가장 자연스럽습니다.

누가 그런코드로 짜놓은 소스가 있는데요..
보면 소스다지우고 싶습니다..^^;
메모리 오류도 많을뿐만아니라 메모리 할당해제도 재대로 안되있거든요..함수재사용은 매우안되고 있고..
문제는 오류를 잡아내기 무척힘듭니다.또한속도 무지 늦고..
시스템 리소스 엄청많이먹네요..

OOP의 캡슐화.. 이건 캡슐다까봐야할 실정이네요..이런건 절대 하지맙시다..ㅎㅎ

C++에서도 내부적으론 this를 파라미터로 넘기고 있는 걸로 압니다.

foo->bar();는

내부적으로

bar(foo);

라고 생각하면 되실 듯 합니다.

구조체내부에 함수포인터 넣어다고 이것이 C++ 일까요..
그것도 C고 모두 C 일뿐입니다. 다만 간단히 해도될것을 억지스럽게 모양만 C++ 흉내낸답시고 그러지말라는것이죠.
드물게 그런사람존재합니다.

몇몇분들이 제글에대해 반론을 제기하셨는데
C적인것은 C문법이 적용되는 모든것이 C 적일수있죠..
즉 C로 가장 효율좋고 편리하게 작성하면 그것이 바로 C적이라봅니다....

제가말하는 하지말자고 했던것은 억지로 C++ 흉내내면 안좋다는것이죠..

ㅡ,.ㅡ;; wrote:

구조체내부에 함수포인터 넣어다고 이것이 C++ 일까요..
그것도 C고 모두 C 일뿐입니다. 다만 간단히 해도될것을 억지스럽게 모양만 C++ 흉내낸답시고 그러지말라는것이죠.
드물게 그런사람존재합니다.

아직도 잘 이해를 못하시는 군요. 님께서 알게모르게 사용하시는 표준 라이브러리 안에서도 C++처럼 보이는것들이 존재합니다. 대표적인것으로 FILE 식별자가 존재하지요. 님께서 사용하시면서도 그 개념이나 의미를 잘 파악 못하시는 것 같은건 아닌지요.

원하신다면 제가 C로 C++적으로 적용했던 일부 코드를 보여드리겠습니다.

제말을 오해하시는군요.. 제가 알게 모르게 사용하는 님이말씀하신 표준라이브러리 안에도 C++처럼 보이는것을이 존재하는것이 아니라 그것이 가장자연스러운 C 처럼 보입니다..
님은 원래 C의 구현방법이었던것을 마치 C++만의 것인양 말씀하시는건 아닌지요..
님은 마치 C와 C++의 특정한구역을 정해두고 서고의 경계를 지나면.. 침범했다고 생각하시는데 그렇지 않다는거죠..
무엇이 C 적이고 무엇이 C++적입니까.. 오히려 제가 묻고 싶군요..
조금넘어갔다고 그것이 C가 C++적인것을 사용한것입니까? 아니죠..오히려그건자연스런일입니다.

#ifdef __cplusplus
extern "C" {
#endif

/******************************************************************************
 DISPATCHER			: Dispatcher 식별자
 size_t size		: 현재 등록되어 있는 fd 수
 size_t maxfds		: 최대 등록 가능한 fd 수(필요에 따라 수시로 증가)
 pollFDs			: 현재 사용하고 있는 struct pollfd 구조체 포인터
******************************************************************************/
typedef struct
{
	size_t size;
	size_t maxfds;
	struct pollfd *pollFDs;
} DISPATCHER;

/******************************************************************************
 Dispatcher_Create(const size_t maxfds)
 Dispatcher_Create는 calloc를 통해 DISATCHER구조체를 생성하고 생성된 구조체를
 반환한다.
******************************************************************************/
DISPATCHER *Dispatcher_Create();


/******************************************************************************
 Dispatcher_Destroy(DISPATCHER *dispatch)
 Dispatcher_Create를 통해 생성된 구조체를 free를 통해 소멸시킨다.
******************************************************************************/
void Dispatcher_Destroy(DISPATCHER *dispatch);


/******************************************************************************
 Dispatcher_Add(DISPATCHER *dispatch)
 DISPATCHER의 식별자에 fd를 추가함으로써 poll이 fd를 감시할 수 있도록 한다.
******************************************************************************/
int Dispatcher_Add(DISPATCHER *dispatch, const int fd);


/******************************************************************************
 Dispatcher_Del(DISPATCHER *dispatch)
 DISPATCHER의 식별자에 fd를 삭제함으로써 poll이 fd를 감시에서 제거한다.
******************************************************************************/
int Dispatcher_Del(DISPATCHER *dispatch, const int fd);


/******************************************************************************
 Dispatcher_Wait(DISPATCHER *dispatch, const long timeout)
 등록된 fd들을 감시한다. 또 한 이 함수를 사용한 시점에서는 Block되며 이벤트
 가 발생할때까지 대기하게 된다. timeout으로 대기시간을 설정하게 되면 대기시
 간 이후에 함수를 빠져나가게 된다. 대기시간은 밀리세컨드이다.
******************************************************************************/
int Dispatcher_Wait(DISPATCHER *dispatch, const long timeout);


/******************************************************************************
 Dispatcher_CurfdsSize(DISPATCHER *dispatch) 
 DISPATCHER 에 현재까지 추가된 소켓의 수를 반환한다.
******************************************************************************/
size_t Dispatcher_CurfdsSize(DISPATCHER *dispatch);

#ifdef __cplusplus
}

poll을 객체형식으로 만들어 놓은겁니다. poll의 지저분한(?) 고유 코드는 다 빠지고 이것만으로 하니 별 신경쓸께 없었습니다. 위의 함수군을 사용하는 일은 다른 사람은 없었습니다. 이것은 밑의 Reactor을 만들기 위해 만들어 놓은 것이죠. 써도 별상관 없겠지만 이걸 익히려 노력은 안하리라 생각했기 때문입니다.

다음은 Reactor패턴을 C수준에서 응용한겁니다. 더 세밀히 하자면 함수포인터를 사용해야 했으나..그럴만한 시간적..ㅜㅜ..

Client Handler(CHandler)는 접속된 각각의 개별 커넥션을 말합니다. 그리고 이것들의 이벤트를 관리하며 처리하는 Reactor이 존재합니다. 사용자는 CHandler의 이벤트 발생시에 처리할 부분을 작성하게 됩니다. 즉 비지니스 로직이 들어갑니다.

Reactor은 TCPCLIENT 객체를 추가하게 되면 CHANDLER(Client Handler)를 생성하게 됩니다. 그리고 CHandler_*함수를 각 이벤트 분류에 따라 호출하게 해줍니다. '유저가 작성해야할 함수' 가 가상함수부분인데...여하튼 이 부분을 사용자가 작성해야 전체가 완성됩니다. 이 부분은 비지니스 로직이 들어가야할 부분이죠. 이것을 바탕으로 OnPacket(..)함수등을 만들어 패킷 처리를 하고 그랬었습니다.

CHandler 클래스를 상속받고, 가상함수등을 이용하고 Reactor에 등록시에도 그렇게 하여야 겠으나 그냥 어찌어찌 만들어진 코드입니다. 핑계를 데면 급히 만든 코드이니......... 또 관리자가 STL을 모른다른 이유로 또 C라는 한정적인 이유로 그냥 배열로 CHandler들을 관리하게 될 허접 SOCKETBOX를 만들었습니다.

그리 잘 따른 코드는 아니나 프레임웍이라 생각하고 보신다면 비지니스로직과 네트워크단의 분류가 확실히 되었음을 아실겁니다.

비지니스로직단에서는 마치 쓰레드를 사용하는것 마냥 착각하게 됩니다.

#ifdef __cplusplus
extern "C" {
#endif

typedef struct
{
	SOCKETBOX	*socketBox;
	DISPATCHER	*dispatcher;
	void		*mainArg;
} REACTOR;

typedef struct
{
	REACTOR		*reactor;
	TCPCLIENT	*tcpClient;
	TIMESPEC	 timeout;
	TIMESPEC	 lastAccessTime;
} CHANDLER;


//유저가 작성해야 하는 함수==================================================
//연결되었을때 호출
int  CHandler_Open(CHANDLER *cHandler, TCPCLIENT *tcpClient, void *mainArg);
//데이터가 들어왔을때 호출
int  CHandler_Input(CHANDLER *cHandler, TCPCLIENT *tcpClient);
//연결이 끊겼을때 호출
void CHandler_Close(CHANDLER *cHandler, TCPCLIENT *tcpClient);
//예약한 시간설정이 되었을때 호출
int  CHandler_TimeOut(CHANDLER *cHandler, TCPCLIENT *tcpClient);

//  REACTOR 생성시 호출될 함수
void  Reactor_Open(REACTOR *Reactor);
//  REACTOR 타임아웃시 호출될 함수
void  Reactor_TimeOut(REACTOR *Reactor);
//  REACTOR 파괴시 또는 종료시 호출될 함수
void  Reactor_Close(REACTOR *Reactor);
//===========================================================================


//  REACTOR 생성자
REACTOR  *Reactor_Create(REACTOR *mainArg);
//  REACTOR 파괴자
void  Reactor_Destroy(REACTOR *Reactor);
//  REACTOR 실행
void  Reactor_Run(REACTOR *Reactor);

//유저가 사용할 수 있는 함수=================================================
//새로운 tcpClient를 등록
int   Reactor_Add(REACTOR *Reactor, TCPCLIENT *tcpClient);
//tcpClient를 삭제
int   Reactor_Del(REACTOR *Reactor, TCPCLIENT *tcpClient);

//타임아웃 설정
void  CHandler_SetTimeOut(CHANDLER *cHandler const int sec);

//fd값을 돌려줌
int   CHandler_Getfd(CHANDLER *cHandler);

//최근 접근 시간 셋팅함.
int   CHandler_SetAccessTime(CHANDLER *cHandler);

//최근 접근 시간 셋팅후 지난 시간을 밀리세컨드로 반환
long  CHandler_GetPastTime(CHANDLER *cHandler);

//자신의 아규먼트를 저장
int   CHandler_SetUserArg(CHANDLER *cHandler void *userArg);

//해당 핸들러에 저장한 아규먼트를 가져옮
void *CHandler_GetUserArg(CHANDLER *cHandler);

//생성시 저장했던 아규먼트를 가져옮
int   CHandler_GetMainArg(CHandler *cHandler);

//TCPCLIENT객체를 가져옮
TCPCLIENT *CHandler_GetTcpClient(CHandler *cHandler);

#ifdef __cplusplus
}
#endif

편집과정에서 몇가지 빠진함수가 있기도 하네요.

위와같이 작성하고 CHandler에서 사용할 변수도 CHandler_SetUserArg로 구조체를 통해 등록하여 사용했습니다. 따라서 전역변수를 일체 사용하지 않아도 되는 코드를 생성할 수 있었으며 연결당 개별관리를 Reactor가 CHandler이란것을 통해 해주었으며 CHandler_Open등에서 -1을 리턴하면 무조건 CHandler_Close를 호출하도록 하여 Close함수를 쓸 이유도 없게 되었구요.

특히나 편리했던 부분은 TimeOut부분을 Reactor에서 관리하고 이벤트처리하여 주므로 프로토콜 문서에 따라 복잡해질 로직이 아주 심하게 편해졌다고 말씀 드릴 수 있네요..TimeOut은 커넥트당 개별관리를 Reactor에서 해줍니다. 일반적으로 처리하는 방식인 일정 시간마다 전체 루프를 돌며 하는것이 아니기 때문에 좀 더 안정적이라고 할 수 있겠죠.

이것을 사용한 결과...다른사람이 사용함으로써 생기는 문제에 있어서 제가 그 사람의 비지니스 로직까지 알 필요 없이 이 부분에 대해서만 점검하거나 버그 수정정도에서 마무리 됩니다. 전 이에 관련된 문서나 알고리즘(?) 정도만 철저히 하면 제가 맡은 소켓 라이브러리 부분은 완료 되는 것이었죠.

다른 사람들은 커넥트되는것을 또 데이터가 들어오는것을, 타임아웃되는것을 직접 코드로 작성할 이유가 없었습니다. 그냥 이벤트가 들어오는 데로 처리하면 되는거니까요. 최소한의 지식은 커넥트와 센드, 서버로 띄우는것인데요. 이것들도 랩핑하여 라이브러리화 했습니다.

아마도 C만 하신 분들은 아주 심하게 생소하리라 추측됩니다. 이의가 있으신분은 언제든지요.....

실력자분들이 엄청 많을텐데...허접한 코드....마니 챙피하네요... :(

잘된구조화란것이 바로 비지니스로직과 Lib 부분이 잘분리된것입니다.

전역을 사용하지 않았다고 객체지향이되것이 아니란건 아실텐데요...
원래 프로그램할때 웬만하면 전역은 사용하지 않죠..

아무리봐도 님프로그램은 구조화를 한것이군요..

물론 저는 구조화가 객체지향보다 뒤지거나 크게 다른의미라고 생각하지도 않습니다만...

제가 작성한 DISPATCHER는 개념적으로 멤버함수들을 가지고 있습니다. 그리고 DISPATCHER구조체는 얼마든지 은닉이 가능한 부분입니다.(해당업체에서 필요이상의 행위는 하지 않았습니다.) 또한 DISPATCHER의 구조체를 다를 줄 아는 함수들은 개념적으로 만들어진 멤버함수들 뿐입니다. 그걸 갑자기 밖으로 끄집어 내서 Reactor에서 주무른다면 어떻게 된다고 생각하십니까? 구조화프로그래밍이라면 충분히 그러고도 남을 상황입니다. 내지는 멤버함수 개념이 없으니 그냥 구조체를 건드리고도 남을 상황인거죠.

umean2me wrote:

#ifdef __cplusplus
extern "C" {
#endif

/******************************************************************************
 DISPATCHER			: Dispatcher 식별자
 size_t size		: 현재 등록되어 있는 fd 수
 size_t maxfds		: 최대 등록 가능한 fd 수(필요에 따라 수시로 증가)
 pollFDs			: 현재 사용하고 있는 struct pollfd 구조체 포인터
******************************************************************************/
typedef struct
{
	size_t size;
	size_t maxfds;
	struct pollfd *pollFDs;
} DISPATCHER;

/******************************************************************************
 Dispatcher_Create(const size_t maxfds)
 Dispatcher_Create는 calloc를 통해 DISATCHER구조체를 생성하고 생성된 구조체를
 반환한다.
******************************************************************************/
DISPATCHER *Dispatcher_Create();


/******************************************************************************
 Dispatcher_Destroy(DISPATCHER *dispatch)
 Dispatcher_Create를 통해 생성된 구조체를 free를 통해 소멸시킨다.
******************************************************************************/
void Dispatcher_Destroy(DISPATCHER *dispatch);


/******************************************************************************
 Dispatcher_Add(DISPATCHER *dispatch)
 DISPATCHER의 식별자에 fd를 추가함으로써 poll이 fd를 감시할 수 있도록 한다.
******************************************************************************/
int Dispatcher_Add(DISPATCHER *dispatch, const int fd);


/******************************************************************************
 Dispatcher_Del(DISPATCHER *dispatch)
 DISPATCHER의 식별자에 fd를 삭제함으로써 poll이 fd를 감시에서 제거한다.
******************************************************************************/
int Dispatcher_Del(DISPATCHER *dispatch, const int fd);


/******************************************************************************
 Dispatcher_Wait(DISPATCHER *dispatch, const long timeout)
 등록된 fd들을 감시한다. 또 한 이 함수를 사용한 시점에서는 Block되며 이벤트
 가 발생할때까지 대기하게 된다. timeout으로 대기시간을 설정하게 되면 대기시
 간 이후에 함수를 빠져나가게 된다. 대기시간은 밀리세컨드이다.
******************************************************************************/
int Dispatcher_Wait(DISPATCHER *dispatch, const long timeout);


/******************************************************************************
 Dispatcher_CurfdsSize(DISPATCHER *dispatch) 
 DISPATCHER 에 현재까지 추가된 소켓의 수를 반환한다.
******************************************************************************/
size_t Dispatcher_CurfdsSize(DISPATCHER *dispatch);

#ifdef __cplusplus
}

poll을 객체형식으로 만들어 놓은겁니다. poll의 지저분한(?) 고유 코드는 다 빠지고 이것만으로 하니 별 신경쓸께 없었습니다. 위의 함수군을 사용하는 일은 다른 사람은 없었습니다. 이것은 밑의 Reactor을 만들기 위해 만들어 놓은 것이죠. 써도 별상관 없겠지만 이걸 익히려 노력은 안하리라 생각했기 때문입니다.

객체 형식으로 만들었다니.. 님소스를 다보진 않았지만.. 이게 왜.. 객체형식인지 모르겠습니다.
물론 말의 의미를 따져보다면 애초에 IT 분야에 객체라는 말자체 가 모호하지만말이죠..님이 구현한건 OOP 에서 말하는객체와는 약간다른의미인듯하군요..

또한 잘만들려는 생각이 있으면 Lib형태로 만들어 사용하는것은 당연하겠죠.. 당연히 lib내부를 까보는일은 없어야하구요..

한마디로 이것은 흔히말하는 구조화한것이라 볼수 있습니다.

Quote:

다음은 Reactor패턴을 C수준에서 응용한겁니다. 더 세밀히 하자면 함수포인터를 사용해야 했으나..그럴만한 시간적..ㅜㅜ..

Client Handler(CHandler)는 접속된 각각의 개별 커넥션을 말합니다. 그리고 이것들의 이벤트를 관리하며 처리하는 Reactor이 존재합니다. 사용자는 CHandler의 이벤트 발생시에 처리할 부분을 작성하게 됩니다. 즉 비지니스 로직이 들어갑니다.

Reactor은 TCPCLIENT 객체를 추가하게 되면 CHANDLER(Client Handler)를 생성하게 됩니다. 그리고 CHandler_*함수를 각 이벤트 분류에 따라 호출하게 해줍니다. '유저가 작성해야할 함수' 가 가상함수부분인데...여하튼 이 부분을 사용자가 작성해야 전체가 완성됩니다. 이 부분은 비지니스 로직이 들어가야할 부분이죠. 이것을 바탕으로 OnPacket(..)함수등을 만들어 패킷 처리를 하고 그랬었습니다.

CHandler 클래스를 상속받고, 가상함수등을 이용하고 Reactor에 등록시에도 그렇게 하여야 겠으나 그냥 어찌어찌 만들어진 코드입니다. 핑계를 데면 급히 만든 코드이니......... 또 관리자가 STL을 모른다른 이유로 또 C라는 한정적인 이유로 그냥 배열로 CHandler들을 관리하게 될 허접 SOCKETBOX를 만들었습니다.

그리 잘 따른 코드는 아니나 프레임웍이라 생각하고 보신다면 비지니스로직과 네트워크단의 분류가 확실히 되었음을 아실겁니다.

잘된구조화란것이 바로 비지니스로직과 Lib 부분이 잘분리된것입니다.

Quote:

비지니스로직단에서는 마치 쓰레드를 사용하는것 마냥 착각하게 됩니다.

#ifdef __cplusplus
extern "C" {
#endif

typedef struct
{
	SOCKETBOX	*socketBox;
	DISPATCHER	*dispatcher;
	void		*mainArg;
} REACTOR;

typedef struct
{
	REACTOR		*reactor;
	TCPCLIENT	*tcpClient;
	TIMESPEC	 timeout;
	TIMESPEC	 lastAccessTime;
} CHANDLER;


//유저가 작성해야 하는 함수==================================================
//연결되었을때 호출
int  CHandler_Open(CHANDLER *cHandler, TCPCLIENT *tcpClient, void *mainArg);
//데이터가 들어왔을때 호출
int  CHandler_Input(CHANDLER *cHandler, TCPCLIENT *tcpClient);
//연결이 끊겼을때 호출
void CHandler_Close(CHANDLER *cHandler, TCPCLIENT *tcpClient);
//예약한 시간설정이 되었을때 호출
int  CHandler_TimeOut(CHANDLER *cHandler, TCPCLIENT *tcpClient);

//  REACTOR 생성시 호출될 함수
void  Reactor_Open(REACTOR *Reactor);
//  REACTOR 타임아웃시 호출될 함수
void  Reactor_TimeOut(REACTOR *Reactor);
//  REACTOR 파괴시 또는 종료시 호출될 함수
void  Reactor_Close(REACTOR *Reactor);
//===========================================================================


//  REACTOR 생성자
REACTOR  *Reactor_Create(REACTOR *mainArg);
//  REACTOR 파괴자
void  Reactor_Destroy(REACTOR *Reactor);
//  REACTOR 실행
void  Reactor_Run(REACTOR *Reactor);

//유저가 사용할 수 있는 함수=================================================
//새로운 tcpClient를 등록
int   Reactor_Add(REACTOR *Reactor, TCPCLIENT *tcpClient);
//tcpClient를 삭제
int   Reactor_Del(REACTOR *Reactor, TCPCLIENT *tcpClient);

//타임아웃 설정
void  CHandler_SetTimeOut(CHANDLER *cHandler const int sec);

//fd값을 돌려줌
int   CHandler_Getfd(CHANDLER *cHandler);

//최근 접근 시간 셋팅함.
int   CHandler_SetAccessTime(CHANDLER *cHandler);

//최근 접근 시간 셋팅후 지난 시간을 밀리세컨드로 반환
long  CHandler_GetPastTime(CHANDLER *cHandler);

//자신의 아규먼트를 저장
int   CHandler_SetUserArg(CHANDLER *cHandler void *userArg);

//해당 핸들러에 저장한 아규먼트를 가져옮
void *CHandler_GetUserArg(CHANDLER *cHandler);

//생성시 저장했던 아규먼트를 가져옮
int   CHandler_GetMainArg(CHandler *cHandler);

//TCPCLIENT객체를 가져옮
TCPCLIENT *CHandler_GetTcpClient(CHandler *cHandler);

#ifdef __cplusplus
}
#endif

편집과정에서 몇가지 빠진함수가 있기도 하네요.

위와같이 작성하고 CHandler에서 사용할 변수도 CHandler_SetUserArg로 구조체를 통해 등록하여 사용했습니다. 따라서 전역변수를 일체 사용하지 않아도 되는 코드를 생성할 수 있었으며 연결당 개별관리를 Reactor가 CHandler이란것을 통해 해주었으며 CHandler_Open등에서 -1을 리턴하면 무조건 CHandler_Close를 호출하도록 하여 Close함수를 쓸 이유도 없게 되었구요.

특히나 편리했던 부분은 TimeOut부분을 Reactor에서 관리하고 이벤트처리하여 주므로 프로토콜 문서에 따라 복잡해질 로직이 아주 심하게 편해졌다고 말씀 드릴 수 있네요..TimeOut은 커넥트당 개별관리를 Reactor에서 해줍니다. 일반적으로 처리하는 방식인 일정 시간마다 전체 루프를 돌며 하는것이 아니기 때문에 좀 더 안정적이라고 할 수 있겠죠.

이것을 사용한 결과...다른사람이 사용함으로써 생기는 문제에 있어서 제가 그 사람의 비지니스 로직까지 알 필요 없이 이 부분에 대해서만 점검하거나 버그 수정정도에서 마무리 됩니다. 전 이에 관련된 문서나 알고리즘(?) 정도만 철저히 하면 제가 맡은 소켓 라이브러리 부분은 완료 되는 것이었죠.

다른 사람들은 커넥트되는것을 또 데이터가 들어오는것을, 타임아웃되는것을 직접 코드로 작성할 이유가 없었습니다. 그냥 이벤트가 들어오는 데로 처리하면 되는거니까요. 최소한의 지식은 커넥트와 센드, 서버로 띄우는것인데요. 이것들도 랩핑하여 라이브러리화 했습니다.

아마도 C만 하신 분들은 아주 심하게 생소하리라 추측됩니다. 이의가 있으신분은 언제든지요.....

실력자분들이 엄청 많을텐데...허접한 코드....마니 챙피하네요... :(

전역을 사용하지 않았다고 객체지향이되것이 아니란건 아실텐데요...
원래 프로그램할때 웬만하면 전역은 사용하지 않죠..

아무리봐도 님프로그램은 구조화를 한것이군요..

물론 저는 구조화가 객체지향보다 뒤지거나 크게 다른의미라고 생각하지도 않습니다만...

님이 객체를 모르시나봅니다. 아니면 제글다시 읽어보세요..
그리고 어이없네요.. 누가 C로 OOP구현하지 말라고하던가요?
글을제대로 안읽오보시나보군요..
전체적으로 좀 엉뚱한글을 쓰셨군요..

딴지일지 모릅니다만..
머하러 어렵게 C로 C++ 흉내냅니까... 그냥 C++ 사용하면되지..
C++ 흉내냈다고 해봤자 C++ 같지도 않구요..
C로는 그냥 C 처럼 짜는것이 가장 자연스럽습니다.

누가 그런코드로 짜놓은 소스가 있는데요..
보면 소스다지우고 싶습니다..^^;
메모리 오류도 많을뿐만아니라 메모리 할당해제도 재대로 안되있거든요..함수재사용은 매우안되고 있고..
문제는 오류를 잡아내기 무척힘듭니다.또한속도 무지 늦고..
시스템 리소스 엄청많이먹네요..

OOP의 캡슐화.. 이건 캡슐다까봐야할 실정이네요..이런건 절대 하지맙시다..ㅎㅎ

irondog wrote:

잘 만들어진 클래스를 쓰더라도 상속 받아서 기능을 확장하려면 해당 소스를 정확히 분석하지 않고는 무서워서 확장하기 힘들죠. 메모리 관리가 막 꼬이면서 알 수 없는 오류를 마구 만들게 되거든요. 상속이라는게 코드의 흐름에 끼어들 수 밖에 없는데 소스를 다 보기 전에는 오류 만들기 아주 쉽죠.

글쎄요... 상속받기 위해서는 소스 코드가 아니라 부모 클래스의 문서를 봐야 하지
않습니까? 그 문서에서는 클래스의 사용법이 당연히 나와 있겠고요. 소스 코드를
봐야 하는 상황 자체가 비정상적이라고 봅니다.

irondog wrote:

템플릿 정도라면 모를까 상속을 통해 코드의 재사용성을 높인다는 말도 그래서 말이 안된다고 생각하고 있었습니다.

이 말을 들으면 Qt 개발자를 포함한 많은 사람들이 섭섭해 하겠군요. ;-)

이런이런....위 두글은 제글인데.......

저는 ㅡ,.ㅡ;; 님의 글은 그냥 스킵하고 봅니다. 쓸만한 정보나 깊이있는 생각이 올라왔던 적은 한번도 없었던것 같군요.

제가 맨 처음 이 글타래를 연 까닭은 윗분께서 말씀하셨듯이 C로 OOP를 할 수 있나? 하는 궁금증에서 였습니다.
왜 C++이 아니고 C냐? 하시면 사실은 제가 운영체제 제작에 관심이(관심만?) 있어서 그렇습니다.
많은 osdev 사이트를 돌아다니고 하다보면 초보자(!)에게는 C가 커널 제작에 다른 어떤 언어보다
유리할 가능성이 크다는 것을 많이 보았습니다. (많은 튜토리얼들과 예제들이 C로 짜여 있음으로부터 시작해서)
그런데 어느 분이 지적하신 것처럼 VFS에서는 OOP 개념이 필요하기도 할 때가 있어서 C로 OOP가 가능한가?
만약 가능하다면 어떤 식의 구현이 좋은가를 묻고자 질문을 하였습니다만, 질문이 명확하지 않아서 많은 분들이
혼란을 겪으신 것 같습니다. 그 점에 사과드립니다. (__)

a를 파라미터로 넘기는 방법도 물론 좋지만 문법적으로 좀더 C++에 가까운 것은 무엇일까? 하는 호기심에
며칠동안 계속 생각을 해 보았습니다만, 아둔한 제 머리의 한계로는 다음의 코드가 가장 나을 것이라는 결론을 내렸습니다.

#include<stdio.h>

void *this = 0;

void inc_one();
void dec_one();

typedef void (*void_func)(void);

typedef struct my_str {
        int iLen;
        void_func inc;
        void_func dec;
}my_str;

my_str* init_my_str()
{
        my_str *new_my_str = (my_str*) malloc(sizeof(my_str));
        new_my_str->inc = &inc_one;
        new_my_str->dec = &dec_one;
        new_my_str->iLen = 0;
        return new_my_str;
}

void inc_one()
{
        ((my_str*)this)->iLen++;
}

void dec_one()
{
        ((my_str*)this)->iLen--;
}

my_str* SEL (my_str* my_str_this)
{
        this = my_str_this;
        return my_str_this;
}

main()
{
        my_str *a = init_my_str();
        printf("a->iLen = %d\n", a->iLen);
        SEL(a)->inc();
        printf("a->iLen = %d\n", a->iLen);
}

제가 맨 처음 이 글타래를 연 까닭은 윗분께서 말씀하셨듯이 C로 OOP를 할 수 있나? 하는 궁금증에서 였습니다.
왜 C++이 아니고 C냐? 하시면 사실은 제가 운영체제 제작에 관심이(관심만?) 있어서 그렇습니다.
많은 osdev 사이트를 돌아다니고 하다보면 초보자(!)에게는 C가 커널 제작에 다른 어떤 언어보다
유리할 가능성이 크다는 것을 많이 보았습니다. (많은 튜토리얼들과 예제들이 C로 짜여 있음으로부터 시작해서)
그런데 어느 분이 지적하신 것처럼 VFS에서는 OOP 개념이 필요하기도 할 때가 있어서 C로 OOP가 가능한가?
만약 가능하다면 어떤 식의 구현이 좋은가를 묻고자 질문을 하였습니다만, 질문이 명확하지 않아서 많은 분들이
혼란을 겪으신 것 같습니다. 그 점에 사과드립니다. (__)

a를 파라미터로 넘기는 방법도 물론 좋지만 문법적으로 좀더 C++에 가까운 것은 무엇일까? 하는 호기심에
며칠동안 계속 생각을 해 보았습니다만, 아둔한 제 머리의 한계로는 다음의 코드가 가장 나을 것이라는 결론을 내렸습니다.

뭔가 잘 못 된게 아닐까요? 이전 코드가 좀 더 정확한 것 같은데...
이렇게 되면...

int main(void)
{
    my_str *a = init_my_str();
    my_str *b = init_my_str();

    printf("a->iLen = %d\n", a->iLen);
    a->inc();
    b->inc();
    printf("a->iLen = %d\n", a->iLen);
    return 0;
}

클래스의 두번째 인스턴스가 만들어지면 첫번째 인스턴스의 동작에 문제가 생기지 않나요? a->inc() b의 자료를 참조하게 될듯 싶은데...

아래코드는 this란 static 변수를 제거하고, 구조체에 대한 reference를 파라미터를 사용해서 만들었습니다.

이기법은 C를 C++로 흉내낼때 사용하는 기법으로 나온것을
따라 했습니다.

...
    a->inc(a);
    b->dec(b);
...

그렇긴 그렇습니다만, 매크로로

#define SEL ( (this) = (a) )

이렇게 만들면 사용할 때 아래와 같이 매번 type-casting을 해줘야 하는 불편이 있는거 같아서요.

((my_str*)SEL(a))->inc()

혹시 해주지 않고도 사용할수 있는 방법이 있을까요?

템플릿 정도라면 모를까 상속을 통해 코드의 재사용성을 높인다는 말도 그래서 말이 안된다고 생각하고 있었습니다. 차라리 코드의 재사용성을 높이려면 오픈소스로 가는게 맞는 거라고 봅니다. :D

OOP라하면... 추상화, 다형성, 상속 요게 핵심인 것 같은데...
요거 프로그래밍 하면서 잘 적용하고 계시나요?

완전히 알려지지 않은 구조체

C 언어로 은닉 (Encapsulation) 을 구현하는 쓸모있는 방법입니다.
비슷한 방법이 C++ 에서 재번역 의존성 제거법으로도 쓰이고요.
(Herb Sutter 님의 Exceptional C++ 참고)

List of "foo.c" :

#include "bar.h"

int main()
{
   BAR *bar = create_bar();
   use_bar(bar);
   remove_bar(bar);
   return 0;
}

List of "bar.c" :

#include "bar.h"

struct BAR_
{
  int somedata1;
  int somedata2;
  void *memory;
};
typedef struct BAR_ BAR;

BAR *create_bar() { static BAR b; return &b; }
void use_bar(BAR *) {  }
void remove_bar(BAR *) { }

List of "bar.h" :

struct BAR_;

struct BAR_ *create_bar();
void use_bar(struct BAR_ *);
void remove_bar(struct BAR_ *);

C 써본 지 하도 오래되어 잘 모르겠지만,
대충 이 정도면 충분한 것으로 알고 있습니다.
이의 제기 해주세요.