Ugrás a tartalomhoz

name lookup

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

Angol


Főnév

name lookup (tsz. name lookups)

  1. (informatika) A name lookup (névfeloldás) C++-ban azt jelenti, hogy a fordító hogyan találja meg a változókat, függvényeket, osztályokat vagy más neveket egy programban. A névfeloldás során a fordító meghatározza, hogy egy adott azonosító (név) milyen deklarációra hivatkozik.


1. Name Lookup alapelvei

C++-ban a névfeloldás többféleképpen működhet:

  1. Blokkszintű névfeloldás – A fordító a belső (lokális) scope-ban keres először, majd felfelé halad a külső scope-okban.
  2. Osztályok és névterek (namespace-ek) – Az osztályok és névterek befolyásolják a névfeloldást.
  3. ADL (Argument-Dependent Lookup, más néven Koenig Lookup) – Egy függvény neve kereshető a paraméterei által meghatározott névterekben is.


2. Példák a névfeloldásra

(a) Lokális és globális változók közötti névfeloldás

#include <iostream>

int x = 10; // Globális változó

void f() {
    int x = 20; // Lokális változó (árnyékolja a globálisat)
    std::cout << "Lokális x: " << x << std::endl; // 20
}

int main() {
    f();
    std::cout << "Globális x: " << x << std::endl; // 10
    return 0;
}

🔹 A lokális változó árnyékolja a globális változót az adott függvényben.


(b) Osztályokban történő névfeloldás

#include <iostream>

class Auto {
public:
    int sebesseg = 100;

    void mutatSebesseg() {
        int sebesseg = 200; // Lokális változó
        std::cout << "Lokális sebesség: " << sebesseg << std::endl;  // 200
        std::cout << "Tagváltozó sebesség: " << this->sebesseg << std::endl;  // 100
    }
};

int main() {
    Auto a;
    a.mutatSebesseg();
    return 0;
}

🔹 this->sebesseg segítségével elérhetjük az osztály tagváltozóját, mert a lokális változó árnyékolja azt.


(c) Namespace alapú névfeloldás

#include <iostream>

namespace A {
    int x = 10;
}

namespace B {
    int x = 20;
}

int main() {
    std::cout << A::x << std::endl; // 10
    std::cout << B::x << std::endl; // 20
    return 0;
}

🔹 Ha több azonos nevű változó van különböző névterekben, akkor a névtérnév (A::x, B::x) alapján lehet elérni a megfelelő változót.


(d) Argument-Dependent Lookup (ADL, Koenig lookup)

#include <iostream>

namespace MyNamespace {
    struct MyClass {};
    
    void f(MyClass) { // A függvény a MyNamespace-ben van
        std::cout << "MyNamespace::f meghívva" << std::endl;
    }
}

int main() {
    MyNamespace::MyClass obj;
    f(obj); // ADL segítségével találja meg a függvényt, MyNamespace::f hívódik meg
    return 0;
}

🔹 Az ADL lehetővé teszi, hogy a fordító keresse a függvényt a paraméter típusának névterében.


3. Névfeloldási sorrend (Name Lookup Order)

  1. Lokális scope (függvény, blokk, lambda, osztály belseje)
  2. Osztály tagjai (this-> is segíthet)
  3. Globális és névtérbeli változók, függvények
  4. Argument-Dependent Lookup (ADL) bizonyos esetekben


Összegzés

  • A C++ névfeloldási szabályai határozzák meg, hogy a fordító melyik deklarációt használja egy adott névhez.
  • A lokális változók előnyt élveznek a globális változókkal szemben.
  • Névterek (namespace-ek) segítenek elkerülni a névütközéseket.
  • Az Argument-Dependent Lookup (ADL) lehetővé teszi, hogy a függvények a paraméter típusa alapján legyenek megtalálhatóak.


További információk

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