Re: Objectizing C Code
Robby <rsimpson@gmail.com> wrote:
Here's a brainteaser:
I have some legacy C code that I cannot modify for various reasons. I
would like to be able to wrap this code into a C++ class so that I can
create multiple objects to interact with.
To simplify, here's some code:
======================================================
foo.h (Can't modify):
#ifndef _FOO_H_
#define _FOO_H_
#if defined(TEST1) && defined(TEST2)
#error "Cannot define both TEST1 and TEST2"
#endif
#ifdef TEST1
#define OUTVAR 1
#elif defined(TEST2)
#define OUTVAR 2
#else
#error "Need TEST1 or TEST2"
#endif
extern int testInt;
void testFunc();
#endif
======================================================
======================================================
foo.c (Cannot modify):
#include "foo.h"
#include <stdio.h>
int testInt;
void testFunc() {
testInt = OUTVAR;
printf("%d\n", testInt);
}
======================================================
To complicate matters further, I would like to have two different
object types, one where TEST1 is defined, and one where TEST2 is
defined, and I would like for each object to have their own copy of
global variables (like testInt).
Thanks in advance for your help!
if you need both testFuncs and both testInts then if you have the
source to foo.c then you can use the preprocewsor to override the
include guards and include the header twice enclosing in two namespaces
and use a few templates to select the proper namespace. then you can
create two functors that hold the 'old globals' and and a call operator
that calls the proper function and copies the old globals before and
after the call. This could get messy if the real code has dozens
of defines and global variables.:)
// wrapper.h
#define TEST1
namespace test1
{
#include "foo.h"
}
#undef TEST1
#undef OUTVAR
#undef FOO_H_
namespace test2
{
#include "foo.h"
}
template <int N> struct call_func;
template <> struct call_func<1>
{
static int do_it()
{
test1::testFunc();
return test1::testInt;
{
};
template <> struct call_func<2>
{
static int do_it()
{
test2::testFunc();
return test2::testInt;
}
};
template <int N> wrapper
{
int var;
void operator () ()
{
var = call_func<N>::do_it();
}
}:
// wrapper.cp
#include <cstdio>
#define TEST1
namespace test1
{
#include "foo.c"
}
#undef TEST1
#undef FOO_H_
#undef OUTVAR
#define TEST2
namespace test2
{
#include "foo.c"
}
// end code.
if you don't have the source to foo.c you have a problem:)
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]