Ugrás a tartalomhoz

function overload resolution ambiguity

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

function overload resolution ambiguity (tsz. function overload resolution ambiguities)

  1. (informatika) A function overload resolution ambiguity (függvénytúlterhelés feloldási kétértelműsége) a C++ egyik gyakori fordítási hibája, amikor a fordító nem tudja egyértelműen eldönteni, hogy egy függvényhívás pontosan melyik túlterhelt verzióhoz tartozik. Ez általában akkor fordul elő, ha több függvény is illeszkedhet a hívásra, és a fordító nem tud közülük választani.


🧠 1. Függvénytúlterhelés (Function Overloading) röviden

A C++ lehetővé teszi ugyanazon függvénynév több verziójának deklarálását, ha azok paraméterlistájukban különböznek:

void f(int);
void f(double);
void f(std::string);

A híváskor a fordító kiválasztja a legjobban illeszkedő verziót a megadott argumentumok típusa alapján.


💥 2. Mikor keletkezik ambiguitás?

A fordító hibát dob, ha több lehetőség ugyanolyan jól illeszkedik, például:

void f(int x);
void f(long x);

f(10); // Melyik legyen? Az int is jó, a long is – NEM EGYÉRTELMŰ!

Ez egy ambiguous overload resolution: a 10 lehet int, de egy long is tökéletesen fogadja.


🧾 3. Jellemző okok és példák

1. 📌 Alapértelmezett paraméterek

void f(std::string s, int x = 0);
void f(std::string s);

f("hello"); // Ambiguitás: az elsőhöz x=0 alapértelmezett, a második is megegyezik

2. 📌 Implicit konverziók

void f(int);
void f(float);

f('a'); // char -> int is jó, char -> float is jó

3. 📌 Sablon és nem-sablon keverése

template<typename T>
void f(T x);

void f(int x);

f(42); // Mindkettő illeszkedik – de a nem-sablon preferált

Megoldás: töröld a sablont, ha konkrét típust használsz.

4. 📌 Függvények túl szoros egyezéssel

void f(const std::string&);
void f(std::string&&);

std::string s = "alma";
f(s);          // const std::string&
f("alma");     // melyik? konstrukcióval megy mindkettő felé -> ambiguity lehet

🛠️ 4. Megoldások

✔️ 1. Típus konzisztencia és static_cast

Segítsd a fordítót:

f(static_cast<int>(10));

✔️ 2. Egyik változat törlése

Ha csak egy típust akarsz engedni:

void f(int) = delete;

✔️ 3. Explicit konverzió elkerülése

Használj külön nevet vagy enable_if-et, ha sablonokról van szó.


🔍 5. Összefoglaló: mikor fordulhat elő ambiguity?

Ok Példa
Túlterhelés hasonló típusokkal f(int) és f(long)
Alapértelmezett paraméter f(string, int=0) vs f(string)
Implicit konverziók f(int), f(float) + f('a')
Rvalue és lvalue referenciák f(const T&) vs f(T&&)
Sablon és nem sablon versenyez template<typename T> f(T) vs f(int)


📚 Tippek

  • Fordító üzenetében mindig szerepel: „call of overloaded ‘f(…)’ is ambiguous”
  • Olvasd el a listát, amit a fordító ad – abban lesz az összes illeszkedő változat
  • Használj explicit típusmegadást vagy std::forward, std::move a pontosításra


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=function_overload_resolution_ambiguity&oldid=3498225”