반응형
project에 cpp파일 및 c 파일이 동시에 있을 경우 c파일의 함수를 extern할 때는 extern "C"를 붙인다

이유는 cpp은 compiler에서  이름을 바꿔서 asm코드를 만든다
이유는 함수 overloading을 위해서인데 이 때문에
cpp파일에서 extern 으로 함수를 선언했을 경우에도 cpp규칙에 의해서 함수이름을 name@@YAHHHH@z등으로 바꾸게 된다.
하지만 extern "C"를 선언하게 되면 이름을 바꾸지 않고 name을 그대로 사용하기 때문에
다른 파일에 있는 c function도 사용 가능하다

mm.cpp

#include <stdio.h>

extern "C" int add(int x, int y, int z, int k);

int add(int x, int y)
{
int k = 0;
k = x + y;
return k;
}

int add(int x, int y, int z)
{
int k = 0;
k = x + y + z;
return k;
}


void main()
{
int a = 100, b = 20, c = 30, d = 10, e;
e = add(a,b);
e = add(a, b, c);
e = add(a, b, c, d);
}

mm2.c

int add(int x, int y, int z, int k)
{
int m;
m = x + y + z + k;
return m;
}

반응형

'Tech > 프로그래밍' 카테고리의 다른 글

Deassembly 로 asm코드 확인하는 방법  (0) 2009.12.10
operator = 을 재구현할 때 참조형 반환타입을 선언할 후 있는 이유  (0) 2009.12.10
C에서 C++로 진화하는 단계 밟아보기  (0) 2009.12.10
Layer를 다루는 C프로그래밍으로 단계별 개선  (0) 2009.12.10
C++에서 this에 대해 알아보자  (0) 2009.12.10
반응형
.cpp파일로 

1단계 : 
#include <stdio.h>

typedef struct _sData
{
int num ;
char str[100] ;
} sData ;


void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

void main()
{
sData data = { 0, "\0" } ;
sData obj = { 0, "\0" } ;
int k ;

printf("[ Data fun ]\n") ;
init(&data, "CArA") ;
add(&data, "a7A") ; out(&data) ;

k = number(&data) ; printf("k : [ %d ]\n", k) ;
array(&data) ; out(&data) ;
printf("[ Num : 701450 ]\n") ;
add_int(&data, 701450) ; out(&data) ;

k = check(&data, 'A') ; printf("k : [ %d ]\n", k) ;
sub(&data, 'A') ; out(&data) ;

printf("\n\n[ Obj fun ]\n") ;
init(&obj, "Ellias") ; out(&obj) ;
}


int check(sData *pm, char ch)
{
int u, d ;
for(u=0, d=0 ; pm->str[u] !='\0' ;u++)
if(pm->str[u] == ch)
d++ ;
return d ;
}

void sub(sData *pm, char ch)
{
int u, d ;
for(u=0, d=0 ; pm->str[u]!='\0' ; u++, d++)
((pm->str[u]==ch)?(d--):(pm->str[d]=pm->str[u])) ;
pm->str[d]='\0' ;
pm->num=d ;
}

void add_int(sData *pm, int num)
{
int n = num ;
while(num>10) {
int u ;
for(u=1 ; n>10 ; n=n/10, u = u*10) ;
pm->str[pm->num++] = n + '0' ;
num = num - n*u ;
if((!((u/10 <= num) && (num < u)))&&((num!=0)))
pm->str[pm->num++] = '0' ;
n = num ;
}
pm->str[pm->num++] = num + '0';
pm->str[pm->num] = '\0' ;
}

int number(sData *pm)
{
int u, d ;
for(u=0, d=0 ; u<pm->num ; u++)
if(('0'<=pm->str[u])&&(pm->str[u]<='9'))
d = d * 10 + (pm->str[u]-'0') ;
return d ;
}

void array(sData *pm)
{
char temp ;
int u ;
for(u=0 ; u<pm->num-1 ; u++) {
int d ;
for(d=1 ; d<pm->num-u ; d++)
if(pm->str[d-1] > pm->str[d]) {
temp = pm->str[d-1] ;
pm->str[d-1] = pm->str[d] ;
pm->str[d] = temp ;
}
}
}

void init(sData *pm, char *pstr)
{
int u ;
for(u=0 ; pstr[u]!='\0' ; pm->str[u]=pstr[u++]) ;
pm->str[u]='\0' ;
pm->num=u ;
}

void add(sData *pm, char *pstr)
{
int u, n ;
for(u=0, n=pm->num ; pstr[u]!='\0' ; u++, n++)
pm->str[n]=pstr[u] ;
pm->str[n]='\0' ;
pm->num=n ;
}

void out(sData *pm)
{
printf("[ Num ] : %d\t[ Str ] : %s\n", pm->num, pm->str) ;
}



2단계 : 
C++의 구조체에는 함수를 포함할 수 있으므로 함수를 구조체 안에 넣었음
그리고 scope연산자를 이용해서 함수들의 scope를 sData로 지정

void sData::init(char *pstr)을 compiler는 void sData::init(sData * this, char *pstr)로 인식한다.
m.init("ABC")를 실제로 compiler는 m.init(&m, "ABC")로 인식

#include <stdio.h>

typedef struct _sData
{
int num ;
char str[100] ;
void init(char *pstr) ;
void add(char *pstr) ;
void out() ;
void add_int(int num) ;
int number() ;
void array() ;
int check(char ch) ;
void sub(char ch) ;
} sData ;



void main()
{
sData m = { 0, "\0" } ;
sData n = { 0, "\0" } ;
int k ;

printf("[ Data fun ]\n") ;
m.init("CArA") ;
m.add("a7A") ; m.out() ;

k = m.number() ; printf("k : [ %d ]\n", k) ;
m.array() ; m.out() ;
printf("[ Num : 701450 ]\n") ;
m.add_int(701450) ; m.out() ;

k = m.check('A') ; printf("k : [ %d ]\n", k) ;
m.sub('A') ; m.out() ;

printf("\n\n[ Obj fun ]\n") ;
n.init("Ellias") ; n.out() ;
}


int sData::check(char ch)
{
int u, d ;
for(u=0, d=0 ; str[u] !='\0' ;u++)
if(str[u] == ch)
d++ ;
return d ;
}

void sData::sub(char ch)
{
int u, d ;
for(u=0, d=0 ; str[u]!='\0' ; u++, d++)
((str[u]==ch)?(d--):(str[d]=str[u])) ;
str[d]='\0' ;
num=d ;
}

void sData::add_int(int num)
{
int n = num ;
while(num>10) {
int u ;
for(u=1 ; n>10 ; n=n/10, u = u*10) ;
str[this->num++] = n + '0' ;
num = num - n*u ;
if((!((u/10 <= num) && (num < u)))&&((num!=0)))
str[this->num++] = '0' ;
n = num ;
}
str[this->num++] = num + '0';
str[this->num] = '\0' ;
}

int sData::number()
{
int u, d ;
for(u=0, d=0 ; u<num ; u++)
if(('0'<=str[u])&&(str[u]<='9'))
d = d * 10 + (str[u]-'0') ;
return d ;
}

void sData::array()
{
char temp ;
int u ;
for(u=0 ; u<num-1 ; u++) {
int d ;
for(d=1 ; d<num-u ; d++)
if(str[d-1] > str[d]) {
temp = str[d-1] ;
str[d-1] = str[d] ;
str[d] = temp ;
}
}
}

void sData::init(char *pstr)
{
int u ;
for(u=0 ; pstr[u]!='\0' ; str[u]=pstr[u++]) ;
str[u]='\0' ;
num=u ;
}

void sData::add(char *pstr)
{
int u, n ;
for(u=0, n=num ; pstr[u]!='\0' ; u++, n++)
str[n]=pstr[u] ;
str[n]='\0' ;
num=n ;
}

void sData::out()
{
printf("[ Num ] : %d\t[ Str ] : %s\n", num, str) ;
}


3단계 : 
기본성격이 public인 struct에서는 수납된 data의 접근을 막을 방법이 없음
data의 접근을 제한할 수 있는 class로 바꿔주겠음

#include <stdio.h>

class sData
{
protected : 
int num ;
char str[100] ;

public:
void init(char *pstr) ;
void add(char *pstr) ;
void out() ;
void add_int(int num) ;
int number() ;
void array() ;
int check(char ch) ;
void sub(char ch) ;
};

void main()
{
sData m;
sData n;
int k ;
printf("[ Data fun ]\n") ;
m.init("CArA") ;
m.add("a7A") ; m.out() ;
k = m.number() ; printf("k : [ %d ]\n", k) ;
m.array() ; m.out() ;
printf("[ Num : 701450 ]\n") ;
m.add_int(701450) ; m.out() ;

k = m.check('A') ; printf("k : [ %d ]\n", k) ;
m.sub('A') ; m.out() ;
printf("\n\n[ Obj fun ]\n") ;
n.init("Ellias") ; n.out() ;
}


4단계 : 
이제부터는 class설계 잘하면 된다 ㅎ
C++의 기능들 잘 활용해가면서 ㅎ



























반응형

'Tech > 프로그래밍' 카테고리의 다른 글

operator = 을 재구현할 때 참조형 반환타입을 선언할 후 있는 이유  (0) 2009.12.10
C++과 C가 섞여있을 경우 C 함수를 위해 extern "C" 사용  (0) 2009.12.10
Layer를 다루는 C프로그래밍으로 단계별 개선  (0) 2009.12.10
C++에서 this에 대해 알아보자  (0) 2009.12.10
functor를 이용한 함수 매크로  (0) 2009.12.09
반응형
union을 이용
그안에 있는 pointer선언형으로 compiler가 자동으로 변환해주는 효과를 얻을 수 있음

http://lxr.linux.no/linux+v2.6.13/include/linux/fs.h 에서도 union사용용법을 확인할 수 있음

1단계 : 
#include <stdio.h>

typedef struct _sData
{
int num ;
char str[100] ;
} sData ;

void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

void main()
{
sData data = { 0, "\0" } ;
sData obj = { 0, "\0" } ;
int k ;

printf("\n\n[ Obj fun ]\n") ;
n.init(&n, "Ellias") ;
n.out(&n) ;
printf("[ Data fun ]\n") ;
m.init(&m, "CArA") ;
m.add(&m, "a7A") ; m.out(&m) ;

k = m.number(&m) ; printf("k : [ %d ]\n", k) ;
m.array(&m) ; m.out(&m) ;
printf("[ Num : 701450 ]\n") ;
m.add_int(&m, 701459) ; m.out(&m) ;

k = m.check(&m, 'A') ; printf("k : [ %d ]\n", k) ;
m.sub(&m, 'A') ; m.out(&m) ;

printf("\n\n[ Obj fun ]\n") ;
n.init(&n, "Ellias") ; n.out(&n) ;
}

int check(sData *pm, char ch)
{
int u, d ;
for(u=0, d=0 ; pm->str[u] !='\0' ;u++)
if(pm->str[u] == ch)
d++ ;
return d ;
}

void sub(sData *pm, char ch)
{
int u, d ;
for(u=0, d=0 ; pm->str[u]!='\0' ; u++, d++)
((pm->str[u]==ch)?(d--):(pm->str[d]=pm->str[u])) ;
pm->str[d]='\0' ;
pm->num=d ;
}

void add_int(sData *pm, int num)
{
int n = num ;
while(num>10) {
int u ;
for(u=1 ; n>10 ; n=n/10, u = u*10) ;
pm->str[pm->num++] = n + '0' ;
num = num - n*u ;
if((!((u/10 <= num) && (num < u)))&&((num!=0)))
pm->str[pm->num++] = '0' ;
n = num ;
}
pm->str[pm->num++] = num + '0';
pm->str[pm->num] = '\0' ;
}

int number(sData *pm)
{
int u, d ;
for(u=0, d=0 ; u<pm->num ; u++)
if(('0'<=pm->str[u])&&(pm->str[u]<='9'))
d = d * 10 + (pm->str[u]-'0') ;
return d ;
}

void array(sData *pm)
{
char temp ;
int u ;
for(u=0 ; u<pm->num-1 ; u++) {
int d ;
for(d=1 ; d<pm->num-u ; d++)
if(pm->str[d-1] > pm->str[d]) {
temp = pm->str[d-1] ;
pm->str[d-1] = pm->str[d] ;
pm->str[d] = temp ;
}
}
}

void init(sData *pm, char *pstr)
{
int u ;
for(u=0 ; pstr[u]!='\0' ; pm->str[u]=pstr[u++]) ;
pm->str[u]='\0' ;
pm->num=u ;
}

void add(sData *pm, char *pstr)
{
int u, n ;
for(u=0, n=pm->num ; pstr[u]!='\0' ; u++, n++)
pm->str[n]=pstr[u] ;
pm->str[n]='\0' ;
pm->num=n ;
}

void out(sData *pm)
{
printf("[ Num ] : %d\t[ Str ] : %s\n", pm->num, pm->str) ;
}

2단계 :  
#include <stdio.h>

typedef struct _sData
{
int num ;
char str[100] ;
void (* init)(struct _sData *pm, char *) ; //함수에 대한 선두번지를 갖는 pointer선언
void (* add)(struct _sData *pm, char *) ;
void (* out)(struct _sData *pm) ;
void (* add_int)(struct _sData *pm, int) ;
int (* number)(struct _sData *pm) ;
void (* array)(struct _sData *pm) ;
int (* check)(struct _sData *pm, char) ;
void (* sub)(struct _sData *pm, char) ;
} sData ;

void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

void main()
{
sData m = { 0, "\0" , init, add, out, add_int, number, array, check, sub} ;
sData n = { 0, "\0" , init, add, out, add_int, number, array, check, sub} ;
int k ;

printf("\n\n[ Obj fun ]\n") ;
n.init(&n, "Ellias") ;
n.out(&n) ;
printf("[ Data fun ]\n") ;
m.init(&m, "CArA") ;
m.add(&m, "a7A") ; m.out(&m) ;

k = m.number(&m) ; printf("k : [ %d ]\n", k) ;
m.array(&m) ; m.out(&m) ;
printf("[ Num : 701450 ]\n") ;
m.add_int(&m, 701459) ; m.out(&m) ;

k = m.check(&m, 'A') ; printf("k : [ %d ]\n", k) ;
m.sub(&m, 'A') ; m.out(&m) ;

printf("\n\n[ Obj fun ]\n") ;
n.init(&n, "Ellias") ; n.out(&n) ;
}
함수는 동일


3단계 : 
#include <stdio.h>

typedef struct { 
void *pfun[8]; 
} pData;

typedef struct _sData
{
int num ;
char str[100] ;
union {
struct {
void (* init)(struct _sData *pm, char *) ; //함수에 대한 선두번지를 갖는 pointer선언
void (* add)(struct _sData *pm, char *) ;
void (* out)(struct _sData *pm) ;
void (* add_int)(struct _sData *pm, int) ;
int (* number)(struct _sData *pm) ;
void (* array)(struct _sData *pm) ;
int (* check)(struct _sData *pm, char) ;
void (* sub)(struct _sData *pm, char) ;
};
pData fun_list;
};
} sData ;

void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

const pData fun_list = {init, add, out, add_int, number, array, check, sub} ;

void main()
{
sData m = { 0, "\0"} ;
sData n = { 0, "\0"} ;
int k ;

m.fun_list = n.fun_list = fun_list;
printf("[ Data fun ]\n") ;
m.init(&m, "CArA") ; m.add(&m, "a7A") ; m.out(&m) ; k = m.number(&m) ; printf("k : [ %d ]\n", k) ; m.array(&m) ; m.out(&m) ; printf("[ Num : 701450 ]\n") ; m.add_int(&m, 701459) ; m.out(&m) ; k = m.check(&m, 'A') ; printf("k : [ %d ]\n", k) ; m.sub(&m, 'A') ; m.out(&m) ; printf("\n\n[ Obj fun ]\n") ; n.init(&n, "Ellias") ; n.out(&n) ;
}


4단계 : 

#include <stdio.h>

typedef struct { 
void *pfun[8]; 
} pData;

typedef union _uFun{
struct {
void (* init)(struct _sData *pm, char *) ; //함수에 대한 선두번지를 갖는 pointer선언
void (* add)(struct _sData *pm, char *) ;
void (* out)(struct _sData *pm) ;
void (* add_int)(struct _sData *pm, int) ;
int (* number)(struct _sData *pm) ;
void (* array)(struct _sData *pm) ;
int (* check)(struct _sData *pm, char) ;
void (* sub)(struct _sData *pm, char) ;
};
pData fun_list;
} uFun;

typedef struct _sData
{
int num ;
char str[100];
const uFun * const op;
} sData ;

void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

const uFun fun_list = {init, add, out, add_int, number, array, check, sub} ;

void main()
{
sData m = { 0, "\0", &fun_list} ;
sData n = { 0, "\0", &fun_list} ;
int k ;

//m.fun_list = n.fun_list = fun_list;
printf("[ Data fun ]\n") ;
m.op->init(&m, "CArA") ;
m.op->add(&m, "a7A") ; m.op->out(&m) ;

k = m.op->number(&m) ; printf("k : [ %d ]\n", k) ;
m.op->array(&m) ; m.op->out(&m) ;
m.op->add_int(&m, 7045) ; m.op->out(&m) ;

k = m.op->check(&m, 'A') ; printf("k : [ %d ]\n", k) ;
m.op->sub(&m, 'A') ; m.op->out(&m) ;

printf("\n\n[ Obj fun ]\n") ;
n.op->init(&n, "Ellias") ; n.op->out(&n) ;
}




5단계 : 
warning 제거


#include <stdio.h>

typedef struct { 
void *pfun[8]; 
} pData;

typedef struct {
void (* init)(struct _sData *pm, char*) ; //함수에 대한 선두번지를 갖는 pointer선언
void (* add)(struct _sData *pm, char *) ;
void (* out)(struct _sData *pm) ;
void (* add_int)(struct _sData *pm, int) ;
int (* number)(struct _sData *pm) ;
void (* array)(struct _sData *pm) ;
int (* check)(struct _sData *pm, char) ;
void (* sub)(struct _sData *pm, char) ;
} sData_operations;

typedef union _uFun{
sData_operations sData_op;
pData fun_list;
} uFun;

typedef struct _sData
{
int num ;
char str[100];
const sData_operations * const op;
} sData ;

void init(sData *pm, char *pstr) ;
void add(sData *pm, char *pstr) ;
void out(sData *pm) ;
void add_int(sData *pm, int num) ;
int number(sData *pm) ;
void array(sData *pm) ;
int check(sData *pm, char ch) ;
void sub(sData *pm, char ch) ;

const uFun fun_list = {init, add, out, add_int, number, array, check, sub} ;

void main()
{
sData m = { 0, "\0", &fun_list.sData_op} ;
sData n = { 0, "\0", &fun_list.sData_op} ;
int k ;

//m.fun_list = n.fun_list = fun_list;
printf("[ Data fun ]\n") ;
m.op->init(&m, "CArA") ;
m.op->add(&m, "a7A") ; m.op->out(&m) ;

k = m.op->number(&m) ; printf("k : [ %d ]\n", k) ;
m.op->array(&m) ; m.op->out(&m) ;
m.op->add_int(&m, 7045) ; m.op->out(&m) ;

k = m.op->check(&m, 'A') ; printf("k : [ %d ]\n", k) ;
m.op->sub(&m, 'A') ; m.op->out(&m) ;


printf("\n\n[ Obj fun ]\n") ;
n.op->init(&n, "Ellias") ; n.op->out(&n) ;
}


6단계 : 
compiler의 특성을 이용해 매개변수 list를 생략 가능, 필요하다면 이렇게도 가능
device별 연결될 매개인자 list가 다를 때 활용 할 수 있음
C언어의 관용을 최대한 활용한 예임

typedef struct { 
void *pfun[8]; 
} pData;

typedef struct {
void (* init)() ; //함수에 대한 선두번지를 갖는 pointer선언
void (* add)() ;
void (* out)() ;
void (* add_int)() ;
int (* number)() ;
void (* array)() ;
int (* check)() ;
void (* sub)() ;
} sData_operations;

typedef union _uFun{
sData_operations sData_op;
pData fun_list;
} uFun;

typedef struct _sData
{
int num ;
char str[100];
const sData_operations * const op;
} sData ;

void init() ;
void add() ;
void out() ;
void add_int() ;
int number() ;
void array() ;
int check() ;
void sub() ;











반응형

'Tech > 프로그래밍' 카테고리의 다른 글

C++과 C가 섞여있을 경우 C 함수를 위해 extern "C" 사용  (0) 2009.12.10
C에서 C++로 진화하는 단계 밟아보기  (0) 2009.12.10
C++에서 this에 대해 알아보자  (0) 2009.12.10
functor를 이용한 함수 매크로  (0) 2009.12.09
CreateThread 와 CRT함수들과의 위험성 여부  (0) 2009.12.04
반응형
C++시스템엔지니어를 위한 완벽 가이드(박규환 저)
p348.
C++에서 this에 대해 알아보자
역어셈을 해서 설명해주는 내용이 나옴
C++이 돌아가는 원리를 C의 입장에서 설명해 놓은 부분임

반응형

'Tech > 프로그래밍' 카테고리의 다른 글

C에서 C++로 진화하는 단계 밟아보기  (0) 2009.12.10
Layer를 다루는 C프로그래밍으로 단계별 개선  (0) 2009.12.10
functor를 이용한 함수 매크로  (0) 2009.12.09
CreateThread 와 CRT함수들과의 위험성 여부  (0) 2009.12.04
fopen(CRT) 사용시 멀티스레드(multithread)문제?  (0) 2009.12.01
반응형
수업 내용
1. ADS(Code Warrior , AxD Debugger)
2. H-JTAG(open되어있는 무료 JTAG프로그램(USB는 유료))
3. ARM9 실습보드 세팅
4. ARM instruction 이해 

1. JTAG 설치 (H-JTAG, H-Flash(boot rom 굽는 프로그램)
2. boot rom fusing(Firmwre boot code 넣음)
3. AxD Debugger 연결
4. DNW(Hyper terminal) serial 

int a = 10; // RW
int b = 0 ; // ZI
int c ; // ZI
func()
{
  int d = 20;  //stack
  c ++ ;
 d = d + c;
 printf(___); // RO
}

ZI_LIMIT -----------------------------
                            ZI   : BSS(Block storage start 영역)
RW_LIMIT-----------------------------
                            RW   : DATA(RAM 영역)
RO_LIMIT-----------------------------
                            RO   : TEXT, CODE 영역(RAM/ROM)
RO_BASE-----------------------------





functor를 이용한 함수 매크로

call <--- 함수의 선두번지 + 매개 인자 리스트 

매크로도 return을 가지는 함수처럼 구현이 가능하다
괄호안에 , 로 구분되어있는 expr은 하나하나 실행 후에 마지막 expr값을 assign함 
(개발 편의를 위해 사용가능)

#define function(pfun, num, str) (printf("[%s]\n", str), pfun[num])

int Add(int x, int y) ;
int Sub(int x, int y) ;
int Mul(int x, int y) ;
int Div(int x, int y) ;

void main()
{
int a = 10, b = 20, c ;
int (*pfun[4])(int,int) = { Add, Sub, Mul, Div } ;
c = function(pfun, 2, "multiply")(a, b) ;
printf("[ %d  * %d  = %d ]\n", a, b, c) ;
}

int Add(int x, int y) { return (x+y) ; }
int Sub(int x, int y) { return (x-y) ; }
int Mul(int x, int y) { return (x*y) ; }
int Div(int x, int y) { return (x/y) ; }



#include <stdio.h>
#include <stdlib.h>


int add_int(int x, int y) { return (x+y) ; }
int sub_int(int x, int y) { return (x-y) ; }
int mul_int(int x, int y) { return (x*y) ; }
int div_int(int x, int y) { return (x/y) ; }

float add_float(float x, float y) { return (x+y) ; }
float sub_float(float x, float y) { return (x-y) ; }
float mul_float(float x, float y) { return (x*y) ; }
float div_float(float x, float y) { return (x/y) ; }

#define fun(name0, name1, x, y) name0##_##name1(x, y)

#define out(name0, name1, data) out_##name1(name0, name1, data)

#define out_int(name0, name1, data) \
printf(#name0"_"#name1" : [ %d ]\n", data)
#define out_float(name0, name1, data) \
printf(#name0"_"#name1" : [ %f ]\n", data)



void main()
{
int a = 100, b = 20, c ;
float fa = 50.2, fb = 20.4, fc = 0.0 ;

c = fun(add, int, a, b) ; out(add, int, c) ;
c = fun(div, int, a, b) ; out(div, int, c) ;
c = fun(mul, int, a, b) ; out(mul, int, c) ;

fc = fun(add, float, fa, fb) ; out(add, float, fc) ;
fc = fun(div, float, fa, fb) ; out(div, float, fc) ;
fc = fun(mul, float, fa, fb) ; out(mul, float, fc) ;
}

=====================
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#if 0
struct sData 
{
char *pstr, str[24] ;
int b ;
} ;

int add(int x, int y) { return (x+y) ; } ;
int sub(int x, int y) { return (x-y) ; } ;

void main()
{
sData m = {"GL-209" };

*(((int (**)(int, int))m.str)+0) = add ;
*(*(((int (*(*)[2])(int, int))m.str)+0)+1) = sub ;

*(((int *)m.str)+2) = 100 ;
*(((int *)m.str)+3) = 20 ;

m.b = (*(*(((int (*(*)[2])(int, int))m.str)+0)+0))
(*(((int *)(m.str))+2), *(((int *)(m.str))+3)) ;
printf("[ %d ]\n", m.b) ;

m.b = (*(((int (**)(int, int))(m.str))+1))
(*(((int *)(m.str))+2), *(((int *)(m.str))+3)) ;
printf("[ %d ]\n", m.b) ;

for(int u=0 ; u< 7 ; *(m.str+16+u) = *(m.pstr+u++));
printf("[ %s ]\n", m.str+16) ;
strcpy(m.str, "Arminia-209 Ellias-404") ;
printf("[ %s ]\n", m.str) ;
}
#endif

struct sData 
{
char *pstr;
union {
int (*fun[2])(int, int);
int a[4] ;
char str[24];
};
int b;
} ;

int add(int x, int y) { return (x+y) ; } ;
int sub(int x, int y) { return (x-y) ; } ;

void main()
{
sData m = {"GL-209" };
m.fun[0] = add ;
m.fun[1] = sub ;
m.a[2] = 100 ;
m.a[3] = 20 ;

m.b = m.fun[0](m.a[2], m.a[3]) ;
printf("[ %d ]\n", m.b) ;

m.b = m.fun[1](m.a[2], m.a[3]) ;
printf("[ %d ]\n", m.b) ;

for(int u=0 ; u< 7 ; u++)
m.str[16+u] = m.pstr[u] ;
printf("[ %s ]\n", &m.str[16]) ;


strcpy(m.str, "Arminia-209 Ellias-404") ;
printf("[ %s ]\n", m.str) ;

}
반응형

'Tech > 프로그래밍' 카테고리의 다른 글

Layer를 다루는 C프로그래밍으로 단계별 개선  (0) 2009.12.10
C++에서 this에 대해 알아보자  (0) 2009.12.10
CreateThread 와 CRT함수들과의 위험성 여부  (0) 2009.12.04
fopen(CRT) 사용시 멀티스레드(multithread)문제?  (0) 2009.12.01
멀티스레드에서 모니터의 개념  (0) 2009.11.20

+ Recent posts

티스토리툴바