The SigC++ CORBA API is modeled around this simple IDL interface:

// IDL
module corbaSigC
{
    typedef sequence<any> ParamList;
    
    interface Slot
    {
        any call(in ParamList params);
    };

    interface Signal
    {
        any emit(in ParamList data);
        void connect(in Slot s);
    };
};

Additional C++-only functions regarding this interface are:

// C++
namespace corbaSigC
{

using namespace SigC;

static Signal_impl Signal_impl::create();
static Slot_impl Slot_impl::create();
static Slot_impl Slot_impl::create(Slot1<CORBA::Any *, const ParamList&>);

Signal1<CORBA::Any *, const ParamList&> Signal_impl::sigc_signal();
Slot1<CORBA::Any *, const ParamList&> Slot_impl::sigc_slot();

}

The parameterless create() functions return a fresh CORBA object of
the respective type. The Slot_impl::create(slot) functions returns a
CORBA Slot object corresponing to 'slot'.

The sigc_* methods obviously return the underlying SigC++ object.

To hide this basic, untyped interface from the SigC++ user, I created some
convinience (also C++-only) classes/functions:

SigC::convert(slot):

slot can be either a normal typed SigC++ slot (e.g. Slot1<void, char *>)
- in this case a untyped slot is returned. If a untyped slot is
given as parameter, the function returns a typed slot (whatever type
is requested).

class SigC::CORBASignal#<R, P1, P2, ..., P#>:

These template classes (# represents the number of arguments) serve as
a glue between SigC++ and CORBA signals and contain associated SigC++
and CORBA signals. You can create them using the following
constructors:

CORBASignal#<R, P1, P2, ...>(Signal#<R, P1, P2, ...>&)

This means the underlying CORBA signal is emitted when the SigC++
signal given as argument is emitted.

CORBASignal#<R, P1, P2, ...>(Signal_ptr signal)

This means the underlying SigC++ signal is emitted when the CORBA
signal given as argument is emitted.

CORBASignal#<R, P1, P2, ...>(Signal_ptr signal, Signal#<R, P1, P2, ...>&)
CORBASignal#<R, P1, P2, ...>(Signal#<R, P1, P2, ...>&, Signal_ptr signal)

These constructors establish the signal flow from arg1 to arg2, that
is when signal1 is emitted, signal2 is also emitted. (But not the
other way round, since that would create a loop).

