Newsgroup: it.comp.lang.c++
Titolo: call of overloaded function is ambiguous

Ciao gente :p
ho un problema, uso dev c++, stavo facendo la mia bella classe con due
costuttori, quando in fase di compilazione....
call of overloaded funzione() is ambiguous, candidates are
funzione() or funzione(int, int)
vi metto pure il codice:
[code]
//un costruttore vuoto che inizializza un array di 101 elementi a false
//è giusto scritto così?
IntegerSet::IntegerSet(){
                         bool insieme[101]={false};
                         }//fine costruttore insieme vuoto
IntegerSet::IntegerSet(int n1=-1, int n2=-1, int n3=-1, int n4=-1, int 
n5=-1){
                           insieme[n1]=true;
                           insieme[n2]=true;
                           insieme[n3]=true;
                           insieme[n4]=true;
                           insieme[n5]=true;
                           }//fine costruttore pieno
// E questo è il pezzo che mi da problemi
IntegerSet* IntegerSet::unionOfIntegerSet(IntegerSet* c){
            IntegerSet* unione;
            unione= new IntegerSet; // qui mi dice che è ambiguo...
            for(int i=0; i<101; i++){
                    if(insieme[i]==true && *c[i]==true)
                                                       unione->insertElement(i);
                    }
            }//fine unione
[/code]
dove sbaglio?

             unione= new IntegerSet; // qui mi dice che è ambiguo...
E ha ragione.
Tu stai chiamando il costruttore senza parametri, ma ne hai definiti 
due. Il primo e' ovvio, il secondo e' quello con i 5 parametri assumendo 
i 5 valori di default.
Pur con tutti i dubbi sulla correttezza (e sul senso) del secondo 
costruttore, ti consiglio di togliere il default almeno al primo 
elemento (e magari di dichiararlo explicit).
--
Marco

 Marco
Ti dispiace farmi vedere cosa intendi? Con le modifiche che ho apportato non 
è cambiato quel messaggio di errore... Ti posto qui tutto il codice così se 
lo vuoi incollare sul tuo compilatore... Ma non vorrei che interpretassi un 
qualcosa simile al "questo vuole fatto i compiti"....ti giuro che non è così 
e se ritieni che possa essere una perdita di tempo ti ringrazio lo stesso 
per i tuoi suggerimenti.
##################
#  INTEGERSET.H   #
##################
//IntegerSet.h
class IntegerSet{
      public:
             IntegerSet();
             IntegerSet(int, int, int, int, int);
             void insertElement(int);
             void deleteElement(int);
             IntegerSet* unionOfIntegerSet(IntegerSet*);
             IntegerSet* intersectionOfIntergerSet(IntegerSet*);
             void setPrint();
             bool isEqualTo(IntegerSet*);
      private:
              bool insieme[101];
              bool verificaContenuto();
      };
###################
# INTEGERSET.CPP #
###################
//integerset.cpp
#include "IntegerSet.h"
IntegerSet::IntegerSet(){
                         for (int i=0; i<101; i++) insieme[i]=false;
                         }//fine costruttore insieme vuoto
IntegerSet::IntegerSet(int n1=-1, int n2=-1, int n3=-1, int n4=-1, int 
n5=-1){
                           if(n1<101&&n1>0) insieme[n1]=true;
                           if(n2<101&&n2>0) insieme[n2]=true;
                           if(n3<101&&n3>0) insieme[n3]=true;
                           if(n4<101&&n4>0) insieme[n4]=true;
                           if(n5<101&&n5>0) insieme[n5]=true;
                           }//fine costruttore pieno
void IntegerSet::insertElement(int i){
     insieme[i]=true;
     }//fine insert
void IntegerSet::deleteElement(int i){
     insieme[i]=false;
     }//fine delete
IntegerSet* IntegerSet::unionOfIntegerSet(IntegerSet* c){
            IntegerSet* unione;
            unione= new IntegerSet;
            for(int i=0; i<101; i++){
                    if(insieme[i]==true && *c[i]==true)
                                                       unione->insertElement(i);
                    }
            }//fine unione
IntegerSet*  IntegerSet::intersectionOfIntegerSet(IntegerSet* c){
             IntegerSet* intersezione;
             intersezione=new IntegerSet;
             for(int i=0; i<101; i++){
                         if(insieme[i]==*c[i])
                                               intersezione->insertElement(i);
                     }
             return intersezione;
}//fine intersezione
bool IntegerSet::verificaContenuto(){
     bool vuoto=true;
      for (int i=0; i<101; i++){
          if(insieme[i]!=false) {
                                vuoto=false;
                                break;
                                }
          }
      return vuoto;
     }
void IntegerSet::setPrint(){
     if(verificaContenuto()) cout<<"l'insieme e' vuoto"<<endl;
     else{
          cout<<"Contenuto dell'insieme"<<endl;
          for (int i=0, x=0; i<101; i++){
                                         if(insieme[i]) {
                                                        cout<<setw(2)<<insieme[i];
                                                        x++;
                                         }
                                         if (x%10==0) cout<<endl;
         }
     }
}//fine print
bool IntegerSet::isEqualTo(IntegerSet* c){
     bool uguali=false;
     for (int i=0, x=0; i<101; i++){
         if(insieme[i]==*c[i])uguali=true;
         else{
              uguali=false;
              break;
              }//fine else
         }//fine for
     return uguali;
     }//fine uguali
##############
# TESTER.CPP #
##############
#include <cstdlib>
#include <iostream>
#include "IntegerSet.h"
using namespace std;
int main(int argc, char *argv[])
{
    IntegerSet insieme1, insieme2;
    //stempo gli insiemi non ancora riempiti
    cout<<"########################################"<<endl;
    cout<<"# STAMPA DEGLI INSIEMI VUOTI           #"<<endl;
    cout<<"########################################"<<endl<<endl;
    cout<<"Insieme1 "<<endl;
    insieme1.setPrint();
    cout<<endl<<endl;
    cout<<"Insieme2 "<<endl;
    insieme2.setPrint();
    cout<<endl<<endl;
    //inserisco degli elementi nell'insieme1
    insieme1.insertElement(1);
    insieme1.insertElement(5);
    insieme1.insertElement(18);
    insieme1.insertElement(34);
    insieme1.insertElement(78);
    insieme1.insertElement(33);
    //inserisco elementi all'insieme2
    insieme2.insertElement(2);
    insieme2.insertElement(45);
    insieme2.insertElement(23);
    insieme2.insertElement(67);
    insieme2.insertElement(33);
    //stampo gli insiemi riempiti
    cout<<"########################################"<<endl;
    cout<<"# STAMPA DEGLI INSIEMI APPENA RIEMPITI #"<<endl;
    cout<<"########################################"<<endl<<endl;
    cout<<"Insieme1 "<<endl;
    insieme1.setPrint();
    cout<<endl<<endl;
    cout<<"Insieme2 "<<endl;
    insieme2.setPrint();
    cout<<endl<<endl;
    //cancello elementi
    cout<<"cancello elementi"<<endl;
    insieme1.deleteElement(5);
    insieme2.deleteElement(45);
    cout<<"Insieme1 "<<endl;
    insieme1.setPrint();
    cout<<endl<<endl;
    cout<<"Insieme2 "<<endl;
    insieme2.setPrint();
    cout<<endl<<endl;
    //unisco i due insiemi
    cout<<"########################################"<<endl;
    cout<<"# UNIONE DEGLI INSIEMI                 #"<<endl;
    cout<<"########################################"<<endl<<endl;
    insieme1.unionOfIntegerSet(&insieme2)->setPrint();
    cout<<endl<<endl;
    //intersezione
    cout<<"########################################"<<endl;
    cout<<"# INTERSEZIONE DEGLI INSIEMI           #"<<endl;
    cout<<"########################################"<<endl<<endl;
    insieme1.intersectionOfIntergerSet(&insieme2)->setPrint();
    cout<<endl<<endl;
    system("PAUSE");
    return EXIT_SUCCESS;
}

 per i tuoi suggerimenti.
Nessun problema, oggi ho tempo libero =)
--
Marco


Inserendo l'explicit nel secondo costruttore ma non togliendo il valore di
dafault....il messaggio rimane sempre lo stesso, scuami ma è ambiguo per
quel fatto che ti ho detto io? Oppure per qualcosa che non so?
[code]
IntegerSet* IntegerSet::unionOfIntegerSet(IntegerSet* c){
            IntegerSet* unione;
            unione= new IntegerSet;
            for(int i=0; i<101; i++){
                    if(insieme[i]==true && *c[i]==true)
                                                       unione->insertElement(i);
                    }
            }//fine unione
[/code]
questo pezzo da come errore: "no match for 'operator*' in '**((+(((unsigned
int)i)* 101u)) + c) "
Allora la funzione ritorna un puntatore ad un oggetto di tipo integerset,
voglio fare così perchè: supposti A e B due insiemi, di questi voglio fare
l'intersezione, A intersezione B, quindi prendo l'oggetto A e chiamo il
metodo interno di intersezione passandogli il puntatore di B e poi mi viene
ritornato un puntatore ad un nuovo oggetto integerset....a senso mio l'ho
scritto così
insieme1.unionOfIntegerSet(&insieme2)->setPrint();
ora nell'intestazione della funzione non viene accettato un puntatore che
viene inizializzato con l'indirizzo di insieme2?

 int)i)* 101u)) + c) "
Giusto per sapere, che compilatore stai usando?!?
E come hai implementato l'operatore [] su IntegerSet, se l'hai implementato?
Inoltre la funzione che hai scritto fa l'intersezione, non l'unione...
--
Marco

 Inoltre la funzione che hai scritto fa l'intersezione, non l'unione...
Si a parte l'implementazione...hai ragione...fa l'intersezione...ma poco 
importa....il problema è risolvere la questione dell'operatore, ieri ci ha 
spiegato come farlo, ma in teoria in questo caso io non dovrei usarlo perchè 
fa parte dell'altra esercitazione... Quando non sapevamo cosa fosse 
l'overloading degli operatori...  Uso dev.
Il principio che vorrei sfruttare è:
Chiamo una funzione di un oggetto all'interno di questa funzione viene 
creato un altro oggetto e ritornato un puntatore all'oggetto creato.... A 
senso mio non spreco memoria per i due insiemi che già ho, facendo copie 
inutili, ma creo solo un terzo oggetto che ne contiene l'unione o 
l'intersezione...
Quindi ritorno un tipo puntatore a IntegerSet e accetto un puntatore a: 
IntegerSet* c; il puntatore è una variabile che contiene un numero e questo 
numero corrisponde ad un indirizzo di memoria. Facendo in questo modo io 
invoco la funzione
insieme1.unionOfIntegerSet(&insieme2)
passandogli un numero che è l'indirizzo dell'oggetto insieme2, questo, 
secondo me, si memorizza in c....
Poi c non si può trattare come se fosse insieme2 direttamente? Come faccio 
per confrontare gli elementi dell'insieme1 con quelli dell'insieme2.... Lo 
so che l'ho scritto io il codice...e non sembra....il fatto è che vorrei 
sfruttare i puntatori in questo modo e non riesco a crearmi da solo uno 
schema semplice sul passaggio dei puntatori....
Quello che so io è che il puntatore contiene l'indirizzo della variabile 
puntata, nel mio caso c contiente l'indirizzo dell'oggetto, ora l'oggetto 
contiene solo l'array di 100 elementi, quindi se devo accedere all'elemento 
i dell'oggetto perchè non posso fare c[i]? Dato che c contiene solo un 
indirizzo, in teoria prima dovrei dereferenziare per c e poi accedere alla 
cella...*c[i] ecco perchè scrivo così...no? Oppure potrei fare un metodo 
dentro la classe integerset che ritorni l'elemento alla posizione x...e poi 
farei un confronto con un qualcosa del tipo *c.getElementAt(i)....la 
dereferenziazione ci va o no?