Newsgroup: it.comp.lang.c
Titolo: Aiuto per compatibilità tra C++ e ANSI C

Ho un problema, ho creato un'applicazione in c++ che mi gestisce i
valori dati in ingresso da tastiera come alberi binari, e tramite gli
algoritmi degli stessi ho creato delle funzioni che mi gestiscono:
-inserimento,
-cancellazione,
-ricerca,
-stampa a video in diverse modalità,
-e infine unione, intersezione e differenza dei due alberi definiti;
solo che avendo sempre programmato in c++, ora che per problemi di
incompatibilità devo rendere tutto compatibile all'ANSI C, e nn
trovando nessuna dispensa o altro di esauriente sulle differenze mi
appello alla vostra "clemenza" e vi chiedo aiuto!
Qui di seguito scrivo il codice sorgente avviabile del "main" e della
libreria chiamata "InsiemeInt.h" in cui ho messo le mie funzioni:
***************************
main file
***************************
#include"InsiemeInt.h" // InsiemeInt.h è il file contenente
l'implementazione dell'albero
void main()
{
	int scelta;
	tipobase elem,a;
	btree abr, abr2;
	MAKENULL(abr);
	MAKENULL(abr2);
	do {
		printf( "\n\n*****************");
		printf( "\n****  MENU'  ****");
		printf( "\n*****************\n\n");
		printf( " 1-Inserimento valori primo albero (A)\n");
		printf( " 2-Inserimento valori secondo albero (B)\n");
		printf( " 3-Ricerca\n");
		printf( " 4-Cancellazione\n");
		printf( " 5-Visita Albero Binario di Ricerca in Preordine\n");
		printf( " 6-Visita Albero Binario di Ricerca in Ordine\n");
		printf( " 7-Visita Albero Binario di Ricerca in Postordine\n");
		printf( " 8-Visualizza l'intersezione dei due insiemi (A e B)\n");
		printf( " 9-Visualizza l'unione dei due insiemi (A + B)\n");
		printf( "10-Visualizza la differenza dei due insiemi(A - B)\n");
		printf( "11-Fine\n");
		printf( "\nInserisci la scelta: ");
		scanf("%d",&scelta);
		switch(scelta) {
			case 1 : {
						printf( "\nDammi l'elemento da Inserire: ");
						scanf("%d",&elem);
						INSERT(abr,elem);
						break;
						}
			case 2 : {
						printf( "\nDammi l'elemento da Inserire: ");
						scanf("%d",&elem);
						INSERT(abr2,elem);
						break;
						}
			case 3 : {
						printf("\nIn quale albero vuoi cercare(1-2)? ");
						scanf("%d",&a);  
						if(a==1){
								if (EMPTYNODE(ROOT(abr))) printf( "\nPrimo albero Vuoto");
									else {
											printf( "\nInserisci l'Elemento da Ricercare ");
											scanf("%d",&elem);
											if (MEMBER(abr,elem)) printf( "\nElemento Trovato");
												else printf( "\nElemento non Trovato");
											}
									}
							else {
								if (EMPTYNODE(ROOT(abr2))) printf( "\nSecondo albero Vuoto");
									else {
											printf( "\nInserisci l'Elemento da Ricercare ");
											scanf("%d",&elem);
											if (MEMBER(abr2,elem)) printf( "\nElemento Trovato");
												else printf( "\nElemento non Trovato");
											}
									}
 
						break;
						}
			case 4 : {
						printf("\nDa quale albero vuoi cancellare(1-2)? ");
						scanf("%d",&a);  
						if(a==1) {
								if (EMPTYNODE(ROOT(abr))) printf( "\nIl primo albero e' Vuoto
");
									else {
											printf( "\nInserisci l'Elemento da Cancellare ");
											scanf("%d",&elem);
											DELETE(abr,elem);
											}         
									}
							else {
									if (EMPTYNODE(ROOT(abr2))) printf( "\nIl secondo albero e'
Vuoto ");
										else {
												printf( "\nInserisci l'Elemento da Cancellare ");
												scanf("%d",&elem);
												DELETE(abr2,elem);
												}         
									}
 
						break;
						}
			case 5 : {
						if (EMPTYNODE(ROOT(abr))) printf( "\nPrimo albero Vuoto ");
							else {  printf("\ni valori del primo albero sono: ");
									preordine(ROOT(abr));}
									if (EMPTYNODE(ROOT(abr2))) printf( "\nSecondo albero Vuoto
");
										else {  printf("\ni valori del secondo albero sono: ");
												preordine(ROOT(abr2));
											}
						break; 
						}
			case 6 : {
						if (EMPTYNODE(ROOT(abr))) printf( "\nPrimo albero Vuoto ");
							else { printf("\ni valori del primo albero sono: ");
								   inordine(ROOT(abr));
								}
						if (EMPTYNODE(ROOT(abr2))) printf( "\nSecondo albero Vuoto ");
							else { printf("\ni valori del secondo albero sono: "); 
								   inordine(ROOT(abr2));
								}
						break; 
						}
			case 7 : {
						if (EMPTYNODE(ROOT(abr))) printf( "\nPrimo albero Vuoto ");
							else { printf("\ni valori del primo albero sono: ");
								   postordine(ROOT(abr));
								}
						if (EMPTYNODE(ROOT(abr2))) printf( "\nSecondo albero Vuoto ");
							else { printf("\ni valori del secondo albero sono: ");
								   postordine(ROOT(abr2));
								}
						break;
						}
			case 8 : {	
						intersezione(ROOT(abr),ROOT(abr2));
						break;
						}
			case 9 : {	
						unione(ROOT(abr),ROOT(abr2));
						break;
						}
			case 10 : {	
						differenza(ROOT(abr),ROOT(abr2));
						}
			}
	} 
while (scelta<11);
}
***********************
InsiemeInt.h
***********************
//includo le librerie necessarie
#include<stdio.h>
#include<stdlib.h>
//definisco il tipo tipobase come int
typedef int tipobase;
//definisco il tipo boolean come int
typedef int boolean;
//definisco la struttura node 
typedef struct node {
	tipobase info;
	struct node * leftchild , * rightchild;
	} * nodo;
nodo DELMIN(nodo &p);
//definisco il tipo btree come nodo
typedef nodo btree;
//imposto alberovuoto come NULL
#define ALBEROVUOTO NULL
//funzione che passato in ingresso un nodo restitutisce 1(true) se non
esiste
int EMPTYNODE(nodo n)
{
	return(n==ALBEROVUOTO);
}
//funzione che passato in ingresso un nodo restitutisce il puntatore
al figlio sinistro
nodo LEFTCHILD(nodo n)
{
	return(n->leftchild);
}
//funzione che passato in ingresso un nodo restitutisce il puntatore
al figlio destro
nodo RIGHTCHILD(nodo n)
{
	return(n->rightchild);
}
//funzione che passato in ingresso un nodo restitutisce il puntatore
al valore figlio destro
tipobase LABEL(nodo n)
{
	return(n->info);
}
//funzione che passato in ingresso l'albero restitutisce il puntatore
alla radice
nodo ROOT(btree t)
{
	return(t);
}
//funzione che passato in ingresso l'albero gli attribuisce il valore
NULL
void MAKENULL(btree &t)
{
	t=ALBEROVUOTO;
}
//funzione che passato in ingresso un nodo e un valore(di tipo
tipobase), verifica la presenza
//del valore nel sottoalbero di cui questo nodo è la radice:
trovato->1 altrimenti 0
int MEMBER(nodo n, tipobase x)
{
	if (EMPTYNODE(n)) return(0);
	if (LABEL(n)==x) return(1);
	if (LABEL(n)>x) return(MEMBER(LEFTCHILD(n),x));
		else return(MEMBER(RIGHTCHILD(n),x));
}
//funzione che passato in ingresso un nodo e un valore di tipo
tipobase, se l'albero è vuoto
//ne "crea" la radice con x, altri
void INSERT(nodo &n, tipobase x)
{
	if (EMPTYNODE(n)) {
					n=new struct node;
					n->info=x;
					n->leftchild=n->rightchild=ALBEROVUOTO;
					}
		else if (LABEL(n)>x) INSERT(n->leftchild,x);
				else if (LABEL(n)<x) INSERT(n-rightchild,x);
}
void DELETE(nodo &n, tipobase x)
{
	if (!EMPTYNODE(n)) 
		{
		if (n->info==x) 
			{
			nodo tmp=n;
			if (EMPTYNODE(n->leftchild)) 
				{
				n=n->rightchild;
				delete tmp;
				} 
				else if (EMPTYNODE(n->rightchild)) 
								{
								n=n->leftchild;
								delete tmp;
								} 
						else 
							{
							n=DELMIN(n->rightchild);
							n->leftchild=tmp->leftchild;
							n->rightchild=tmp->rightchild;
							delete tmp;
							}
			}
		else if (LABEL(n)>x) DELETE(n->leftchild,x);
		else DELETE(n->rightchild,x);
		}
}
nodo DELMIN(nodo &p)
{
	if (p->leftchild==ALBEROVUOTO) 
		{
		nodo pmin=p;
		p=p->rightchild;
		return(pmin);
		} 
		else return(DELMIN(p->leftchild));
}
void accedi(tipobase x)
{
	printf("%d ",x);
}
void preordine(nodo n)
{
	if (!EMPTYNODE(n)) 
		{
		accedi(LABEL(n));
		preordine(LEFTCHILD(n));
		preordine(RIGHTCHILD(n));
		}
}
void inordine(nodo n)
{
	if (!EMPTYNODE(n)) 
		{
		inordine(LEFTCHILD(n));
		accedi(LABEL(n));
		inordine(RIGHTCHILD(n));
		}
}
void postordine(nodo n)
{
	if (!EMPTYNODE(n)) 
		{
		postordine(LEFTCHILD(n));
		postordine(RIGHTCHILD(n));
		accedi(LABEL(n));
		}
}
int altezza(nodo n)
{
	int a=0,h;
	nodo tmp;
	tmp=LEFTCHILD(n);
	if (!EMPTYNODE(tmp)) 
		{
		h=altezza(tmp);
		if (h>=a) a=h+1;
		}
	tmp=RIGHTCHILD(n);
	if (!EMPTYNODE(tmp)) 
		{
		h=altezza(tmp);
		if (h>=a) a=h+1;
		}
	return(a);
}
void distruggi(btree t)
{
	if (!EMPTYNODE((ROOT(t)))) {
	if (t->leftchild != ALBEROVUOTO) distruggi(t->leftchild);
	if (t->rightchild != ALBEROVUOTO) distruggi(t->rightchild);
	delete t;
    t=ALBEROVUOTO;
								}
}
void intersezione(nodo n, nodo m)
	{
	if ((!EMPTYNODE(n))&&(!EMPTYNODE(m))) {
						intersezione(LEFTCHILD(n),m);
						if (MEMBER(m,LABEL(n))) accedi(LABEL(n));
						intersezione(RIGHTCHILD(n),m);
						}
	}
void differenza(nodo n, nodo m)
	{
	if (!EMPTYNODE(n)) {
						differenza(LEFTCHILD(n),m);
						if (!MEMBER(m,LABEL(n))) accedi(LABEL(n));
						differenza(RIGHTCHILD(n),m);
						}
	}
void unione(nodo n, nodo m)
	{
	if ((!EMPTYNODE(n))||(!EMPTYNODE(m))) {
						differenza(n,m);
						preordine(m);
						}
	}
Ringrazio chiunque mi risponda o riesca a darmi anche solo delle
dritte su come risolvere i problemi che mi trovo davanti, ciao e
grazie a tutti, Andrea

 libreria chiamata "InsiemeInt.h" in cui ho messo le mie funzioni:
A prima vista non vedo niente di estraneo al C....
Non ci sono classi, non usi  iostream,
e non mi sembra di vedere neppure dichiarazioni
'ritardate' di variabili.
Hai provato a compilare come C ?
Ciao
E.

 E.
Si sė ho compilato, se fai un copia incolla dei due codici sorgente
vedrai anche te che valanga di errori mi da!
Un po ne ho giā corretti, per esempio le funzioni MAKENULL, INSERT e
DELETE che richiamo nel main, senza la dichiarazione dei prototipi in
C non va.
In pių a quanto pare il linguaggio C non accetta il carattere "&" come
indicativo dell'indirizzo di una variabile;
la funzione "delete" (tutto minuscolo), che č una funzione riservata
predefinita di C++, non esiste in C, che non so per'altro come emulare
e infine in C non posso utilizzare la "new" per dichiarare una nuova
struttura (come faccio quando verifico, durante l'inserimento, che
l'albero č vuoto), ma a quanto ho capito devo dichiararle "globali" di
tipo struct (nel mio caso di tipo nodo).
Solo che a dirle ste cose sembrano semplici, io so solo di essere
ancora sommerso da errors e warning!!
Accetto suggerimenti di ogni tipo!!

 Accetto suggerimenti di ogni tipo!!
Ciao
E.

 libreria chiamata "InsiemeInt.h" in cui ho messo le mie funzioni:
// ***********************
// InsiemeInt.h
// ***********************
//includo le librerie necessarie
#include<stdio.h>
#include<stdlib.h>
//definisco il tipo tipobase come int
typedef int tipobase;
//definisco il tipo boolean come int
typedef int boolean;
//definisco la struttura node 
typedef struct node {
	tipobase info;
	struct node * leftchild , * rightchild;
	} * nodo;
nodo DELMIN(nodo p);








void MAKENULL(btree t)
{
	t=ALBEROVUOTO;
}
//funzione che passato in ingresso un nodo e un valore(di tipo
tipobase), verifica la presenza
//del valore nel sottoalbero di cui questo nodo è la radice: trovato->1
altrimenti 0
int MEMBER(nodo n, tipobase x)
{
	if (EMPTYNODE(n)) return(0);
	if (LABEL(n)==x) return(1);
	if (LABEL(n)>x) return(MEMBER(LEFTCHILD(n),x));
		else return(MEMBER(RIGHTCHILD(n),x));
}
//funzione che passato in ingresso un nodo e un valore di tipo tipobase,
se l'albero è vuoto
//ne "crea" la radice con x, altri
void INSERT(nodo n, tipobase x)
{
	if (EMPTYNODE(n)) {
					n=calloc(1, sizeof(struct node)); // new struct node;
					n->info=x;
					n->leftchild=n->rightchild=ALBEROVUOTO;
					}
		else if (LABEL(n)>x) INSERT(n->leftchild,x);
				else if (LABEL(n)<x) INSERT(n->rightchild,x); //n-rightchild
}
void DELETE(nodo n, tipobase x)
{
	if (!EMPTYNODE(n)) 
		{
		if (n->info==x) 
			{
			nodo tmp=n;
			if (EMPTYNODE(n->leftchild)) 
				{
				n=n->rightchild;
				free(tmp); // delete tmp;
				} 
				else if (EMPTYNODE(n->rightchild)) 
								{
								n=n->leftchild;
								free(tmp); // delete tmp;
								} 
						else 
							{
							n=DELMIN(n->rightchild);
							n->leftchild=tmp->leftchild;
							n->rightchild=tmp->rightchild;
							free(tmp); // delete tmp;
							}
			}
		else if (LABEL(n)>x) DELETE(n->leftchild,x);
		else DELETE(n->rightchild,x);
		}
}
nodo DELMIN(nodo p)







	free(t); //delete t;
    t=ALBEROVUOTO;
								}
}
void intersezione(nodo n, nodo m)
	{
	if ((!EMPTYNODE(n))&&(!EMPTYNODE(m))) {
						intersezione(LEFTCHILD(n),m);
						if (MEMBER(m,LABEL(n))) accedi(LABEL(n));
						intersezione(RIGHTCHILD(n),m);
						}
	}
void differenza(nodo n, nodo m)
	{
	if (!EMPTYNODE(n)) {
						differenza(LEFTCHILD(n),m);
						if (!MEMBER(m,LABEL(n))) accedi(LABEL(n));
						differenza(RIGHTCHILD(n),m);
						}
	}
void unione(nodo n, nodo m)
	{
	if ((!EMPTYNODE(n))||(!EMPTYNODE(m))) {
						differenza(n,m);
						preordine(m);
						}
	}
// #include"InsiemeInt.h" // InsiemeInt.h è il file contenente
                          // l'implementazione dell'albero





						break;
						}



			case 8 : {	
						intersezione(ROOT(abr),ROOT(abr2));
						break;
						}
			case 9 : {	
						unione(ROOT(abr),ROOT(abr2));
						break;
						}
			case 10 : {	
						differenza(ROOT(abr),ROOT(abr2));
						}
			}
	} 
while (scelta<11);
}
Il codice compila in "C".
ATTENZIONE! Il codice _compila_: tra compilare ed essere corretto
            c'e una certa differenza. :-)
HTH
C:\>iao Angelo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG