Newsgroup: it.comp.os.linux.development
Titolo: c++

In un programma c posso richiamare delle funzioni da librerie c++? anche le
classi?
grazie

 classi?
Auguri... :-)
E` possibile se ti crei un wrapper in C++ con delle funzioni tra i 
soliti ``extern "C" { .... }'', cosi` il compilatore C++ adotta le 
convenzioni di chiamata del C e non fa il name mangling per i simboli 
del wrapper, ed essi quindi risultano essere visibili dal C.
Le varie funzioni del wrapper andranno ad invocare i metodi sulle 
istanze opportune. Chiaramente, salvo che per le classi singleton, 
dovrai passare come parametro alle funzioni del wrapper anche un 
puntatore all'istanza su cui vuoi invocare il metodo.
Esempione:
----------------------------------------------------------------------
MyClass.h
----------------------------------------------------------------------
#ifndef MyClass_H
#define MyClass_H
class MyClass
{
public:
     int
     getValue() const;
     void
     setValue(int v);
protected:
     int value;
};
----------------------------------------------------------------------
MyClass.cpp
----------------------------------------------------------------------
#include "MyClass.h"
int
MyClass::getValue() const
{
     return value;
}
void
MyClass::setValue(int v)
{
     value = v;
}
----------------------------------------------------------------------
wrapper.h
----------------------------------------------------------------------
#ifndef wrapper_h
#define wrapper_h
#ifdef __cplusplus
extern "C" {
#endif
int
MyClass_getValue(void * instance);
void
MyClass_setValue(void * instance,int v);
void *
MyClass_new(void);
void
MyClass_delete(void * instance);
#ifdef __cplusplus
}
#endif
#endif
----------------------------------------------------------------------
wrapper.cpp
----------------------------------------------------------------------
#include "wrapper.h"
#include "MyClass.h"
void *
MyClass_new(void)
{
     return (void *) new MyClass;
}
void
MyClass_delete(void * instance)
{
     delete ((MyClass *)instance);
}
int
MyClass_getValue(void * instance)
{
     return ((MyClass *)instance)->getValue();
}
void
MyClass_setValue(void * instance, int v)
{
     ((MyClass *)instance)->setValue(v);
}
----------------------------------------------------------------------
main.c
----------------------------------------------------------------------
#include <stdio.h>
#include "wrapper.h"
int
main()
{
     void * myclass;
     int result;
     printf("Istanzio MyClass\n");
     myclass = MyClass_new();
     printf("Assegno un valore\n");
     MyClass_setValue(myclass,42);
     printf("Ripesco il valore\n");
     result = MyClass_getValue(myclass);
     printf("Il valore e` %d\n",result);
     return 0;
}
Compilare con
g++ -c MyClass.cpp -o MyClass.o
g++ -c wrapper.cpp -o wrapper.o
gcc -c main.c -o main.o
gcc main.o wrapper.o MyClass.o -o prova
Dovrebbe funzionare, sembra facile... ma poi:
1) Ovviamente devi catchare tutte le eccezioni possibli nel tuo wrapper, 
visto che il codice C non puo` farlo.
2) Dovrai trovare il modo di girare attorno a tutti quei metodi che 
hanno parametri e/o valori di ritorno che sono tipi complessi (i.e. 
classi) (fuori dalla portata del C), o che sono reference a tipi 
complessi. Considera che in C++ puoi passare oggetti (e strutture) per 
valore (anche se non sarebbe da fare), in C ovviamente no.
Al limite puoi definirti delle strutture C contenenti le informazioni 
necessarie al wrapper per costruire al volo tali oggetti... e passare 
quelle per riferimento.
3) Al solito non bisogna usare free() su memoria allocata con new, e di 
concerto non bisogna usare malloc() o simili con memoria che verra` 
liberata con delete... per cui occhio anche a questo.
4) Mescolare stdio.h e iostream sullo stesso file descriptor sicuramente 
produce casini nell'I/O
Insomma, non e` una cosa proprio banale, e probabilmente ci sono altre 
rogne in vista oltre a quelle elencate.
Se sei proprio disperato quasi quasi mi sa che ti conviene riadattare il 
C che hai per renderlo C++ valido (basta un po' d'attenzione se il 
codice C e` scritto bene e non usa le parole chiave del C++) e compilare 
poi tutto col compilatore C++.

Auguri... :-)
ahhhhhh!!!! forse č meglio un bel porting...
grazie 


Forse potresti semplicemente fare l'inverso, un progetto in C++ e da li
richiamare le funzioni C, cosa abbastanza facile da realizzare ed potrai
cosě utilizzare le classi C++ ma devi stare attento all'allocazione dinamica
e' consiglibile usare quella del C++ (new e delete) .
spero di asserti stato utile.