Acest articol este preocupat de erorile ambigue din limbajul de programare C++. Situația ambiguă apare atunci când compilatorul nu poate determina metodele sau operatorii care trebuie utilizați pentru diferite sarcini. Uneori, folosim aceeași funcție de parametri cu același spațiu de nume, iar apoi cout este definit în ambele cazuri. Când executăm programul, compilatorul generează eroarea ambiguă cout, deoarece compilatorul nu înțelege ce semnificație arată acest cod. Ambiguitatea cout apare atunci când există un conflict între spațiile de nume definite sau declarațiile multiple de funcții din interiorul programului.
Exemplul 1:
Acesta este un exemplu de eroare ambiguă care apare mai ales în programarea C++. Aici, vom vedea cum compilatorul generează erorile ambigue pe cout atunci când folosim mai multe spații de nume. Fragmentul de cod al acestui exemplu este menționat în cele ce urmează:
#include
spatiu de nume laptop {
gol afişa ( ) {
std :: cout << „Acesta este spațiu de nume pentru laptop” << std :: endl ;
}
}
spatiu de nume mobil {
gol afişa ( ) {
std :: cout << „Acesta este spațiu de nume mobil” << std :: endl ;
}
}
int principal ( ) {
folosind spatiu de nume laptop ;
folosind spatiu de nume mobil ;
afişa ( ) ;
întoarcere 0 ;
}
Aici, am luat un program cu două spații de nume care sunt definite în funcție de nevoile noastre. Vrem să afișăm șirurile pe ecran. Ieșirea acestui cod este atașată în următoarele:
La executarea codului, eroarea este generată cu privire la situația ambiguă. Eroarea este generată deoarece atunci când compilatorul citește codul, compilatorul nu primește o intrare clară din partea utilizatorului. Am folosit mai multe declarații de spații de nume în codul nostru. În întregul cod, am folosit metoda „afișare” numai pentru a afișa rezultatul pe ecran. Compilatorul nu are idee ce metodă de afișare este legată de ce spațiu de nume. Trebuie să facem codul simplu și clar, astfel încât compilatorul să înțeleagă cu ușurință pașii fără a face codul ambiguu.
Soluția la această eroare este apelarea metodei cu un spațiu de nume asociat în funcția principală pentru ca compilatorul să înțeleagă mai mult. Specificăm clar ce metodă de spațiu de nume dorim să apelăm în porțiunea noastră principală de execuție.
#includespatiu de nume laptop {
gol afişa ( ) {
std :: cout << „Acesta este spațiu de nume pentru laptop” << std :: endl ;
}
}
spatiu de nume mobil {
gol afişa ( ) {
std :: cout << „Acesta este spațiu de nume mobil” << std :: endl ;
}
}
int principal ( ) {
folosind spatiu de nume laptop ;
folosind spatiu de nume mobil ;
laptop :: afişa ( ) ;
întoarcere 0 ;
}
Aici, putem conecta doar metoda display() cu spațiul de nume „laptop” din funcția principală, așa cum se vede în captura de ecran anterioară. Acum, rulați programul. Ieșirea este afișată în fereastra consolei.
Exemplul 2:
Acest scenariu este legat de eroarea ambiguă cout în C++. Compilatorul arată o eroare atunci când nu înțelege fluxul de execuție. Fragmentul de cod al acestui exemplu este atașat în cele ce urmează:
#includespatiu de nume Limbajul {
gol imprimare ( int i ) {
std :: cout << „Spațiul de nume al limbajului C:” << i << std :: endl ;
}
}
spatiu de nume java {
gol imprimare ( int j ) {
std :: cout << 'Spațiul de nume al limbajului java: ' << j << std :: endl ;
}
}
folosind spatiu de nume Limbajul ;
folosind spatiu de nume java ;
int principal ( ) {
imprimare ( 5 ) ;
întoarcere 0 ;
}
În acest cod, definim toate anteturile bibliotecii necesare. Creăm două spații de nume pentru scopuri diferite. În spațiul de nume „Clanguage”, definim o metodă „print” care preia valoarea întreagă de la utilizator. În funcția „printare”, dorim să arătăm valoarea pe care utilizatorul a transmis-o pe ecranul consolei. Afișăm rezultatul necesar folosind fluxul „cout” din codul nostru. După aceea, definim un alt spațiu de nume al cărui nume este „Java”.
În acest spațiu de nume „Java”, folosim din nou metoda „print” pentru a afișa valoarea pe care utilizatorul o transmite folosind „cout”. Apelăm ambele spații de nume pentru utilizare în funcția noastră principală pentru a obține rezultatul dorit în fereastra consolei în C++. În funcția „principală”, numim funcția supraîncărcată „print()” pentru a afișa valoarea transmisă pe ecranul consolei.
Faceți clic pe opțiunea „executare” din meniul principal și selectați opțiunea „compilare și rulare”. Eroarea despre ambiguitate apare la execuția acestui cod. Captura de ecran de eroare este atașată după cum urmează:
Această eroare indică faptul că compilatorul este confuz cu privire la funcția supraîncărcată print() care este apelată. Această eroare este pe linia 19, „printați (5)”. Compilatorul este confuz cu privire la spațiul de nume căruia îi aparține această funcție supraîncărcată. Începătorii sunt întotdeauna blocați în aceste tipuri de erori de cele mai multe ori.
Să rezolvăm această eroare care nu este complexă în realitate. Erorile ambigue sunt ușor de rezolvat. Trebuie să specificăm spațiul de nume de-a lungul funcției supraîncărcate în funcția „principală” pentru vizibilitate și înțelegere a compilatorului. Ca și în acest program, adăugăm acest „java::print(5)” în codul nostru existent, așa cum este menționat în cele ce urmează:
#includespatiu de nume Limbajul {
gol imprimare ( int i ) {
std :: cout << „Spațiul de nume al limbajului C:” << i << std :: endl ;
}
}
spatiu de nume java {
gol imprimare ( int j ) {
std :: cout << 'Spațiul de nume al limbajului java: ' << j << std :: endl ;
}
}
folosind spatiu de nume Limbajul ;
folosind spatiu de nume java ;
int principal ( ) {
java :: imprimare ( 5 ) ;
întoarcere 0 ;
}
Acum, programul este executat perfect fără nicio eroare ambiguă și afișează rezultatul pe ecranul consolei. Ieșirea acestui program este atașată în următoarele:
Exemplul 3:
Acesta este ultimul și ultimul exemplu legat de o eroare care este generată din cauza unei probleme ambigue. Compilatorul nu poate obține rezultatul corect. Fragmentul de cod al acestui exemplu este atașat în cele ce urmează pentru o mai bună înțelegere de către utilizator:
Aici definim bibliotecile necesare. După aceea, definim un spațiu de nume care conține clasa în care dorim să afișăm șirul pe fereastra consolei. Numim acest spațiu de nume definit în funcția „principală” cu variabila „c”. După aceea, apelăm metoda print() folosind un obiect namespace. Afișăm șirul din nou pe ecranul consolei după apelul metodei. Ieșirea trebuie să fie ambele șiruri și să fie afișate pe ecranul consolei. Când executăm acest cod, eroarea apare așa cum se arată în următoarele:
#includefolosind spatiu de nume std ;
spatiu de nume myNamspace {
clasă cout {
public :
gol imprimare ( ) {
cout << „Cot personalizat” << std :: endl ;
}
} ;
}
int principal ( ) {
myNamspace :: cout c ;
c. imprimare ( ) ;
cout << 'Salut Lume!' << std :: endl ;
întoarcere 0 ;
}
Compilatorul nu a ales instrucțiunea cout care afișează datele pe ecranul consolei. Compilatorul nu poate înțelege spațiul de nume care aparține instrucțiunii cout și generează o eroare. Soluția la această eroare este adăugarea unui obiect de spațiu de nume cu o instrucțiune cout pentru lizibilitatea și înțelegerea compilatorului. Adăugați „std::” de-a lungul instrucțiunii cout și rulați codul. Următoarea ieșire este afișată pe ecranul consolei:
Concluzie
Aici, putem spune că afișarea unei ieșiri pe ecranul consolei generează și o eroare care nu este o eroare de sintaxă și nici o eroare logică. De cele mai multe ori, utilizatorul scrie un sens bun al codului, dar nu este de înțeles pentru compilator. Compilatorul este ambiguu în ceea ce privește intrarea. Așadar, clarificați fiecare pas de cod cu spații de nume și sintaxă adecvate pentru a evita erorile în limbajul de programare C++. Pașii implicați în rezolvarea acestei probleme sunt utilizarea calificatorilor explici, prevenirea ciocnirilor spațiilor de nume și asigurarea faptului că funcțiile sau obiectele vizate au identificat pașii implicați în rezolvarea acestei probleme.