Utilizzo di: in C++

Question

Sto imparando C++ e non posso mai dire quando ho bisogno di usare ::. So che ho bisogno di usare std:: di fronte a cout e cin. Significa che all'interno del file iostream gli sviluppatori che lo hanno creato hanno creato uno spazio dei nomi chiamato std e messo le funzioni cin e cout nello spazio dei nomi chiamato std? Quando ho creato una nuova classe che non è nello stesso file di main() per qualche motivo devo aggiungere ::.

Ad esempio, se creo un class chiamato A, perché devo inserire A:: di fronte a una funzione che creo, anche se non l'ho inserito in un namespace? Ad esempio void A::printStuff(){}. Se creo una funzione in main, perché non devo inserire main::printStuf{}?

So che la mia domanda è probabilmente confusa, ma qualcuno potrebbe aiutarmi?

Answer 1

Hai praticamente ragione su cout e cin. Sono oggetti (non funzioni) definiti all'interno dello spazio dei nomi std. Ecco le loro dichiarazioni come definito dalla norma C++:

Header <iostream> sinossi

#include <ios> 
#include <streambuf> 
#include <istream> 
#include <ostream> 

namespace std { 
    extern istream cin; 
    extern ostream cout; 
    extern ostream cerr; 
    extern ostream clog; 

    extern wistream wcin; 
    extern wostream wcout; 
    extern wostream wcerr; 
    extern wostream wclog; 
} 

:: è noto come il portata risoluzione operatore. I nomi cout e cin sono definiti all'interno di std, pertanto è necessario qualificare il proprio nome con std::.

Le classi si comportano un po 'come gli spazi dei nomi in quanto i nomi dichiarati all'interno della classe appartengono alla classe. Per esempio:

class foo 
{ 
    public: 
    foo(); 
    void bar(); 
}; 

Il costruttore di nome foo è un membro della classe denominata foo. Hanno lo stesso nome perché è il costruttore. La funzione bar è anche membro di foo.

Poiché sono membri di foo, quando ci si riferisce ad essi al di fuori della classe, dobbiamo qualificare i loro nomi. Dopotutto, appartengono a quella classe.Quindi, se avete intenzione di definire il costruttore e bar di fuori della classe, è necessario fare in questo modo:

foo::foo() 
{ 
    // Implement the constructor 
} 

void foo::bar() 
{ 
    // Implement bar 
} 

Questo è perché si stanno definendo di fuori classe. Se non avessi inserito la qualifica foo:: sui nomi, dovresti definire alcune nuove funzioni nell'ambito globale, piuttosto che come membri di foo. Per esempio, questo è completamente diverso bar:

void bar() 
{ 
    // Implement different bar 
} 

È consentito avere lo stesso nome della funzione nella classe foo perché è in un ambito diverso. Questo bar è nell'ambito globale, mentre l'altro bar apparteneva alla classe foo.

Answer 2

Il :: è chiamato operatore di risoluzione dell'ambito. Può essere usato in questo modo:

::identificatore
class-name::identificatore
namespace::identificatore

Si può leggere su qui
http://msdn.microsoft.com/en-us/library/b451xz31(v=vs.80).aspx

Answer 3

Gli :: sono utilizzati per gli ambiti di dereferenziazione.

const int x = 5; 

namespace foo { 
    const int x = 0; 
} 

int bar() { 
    int x = 1; 
    return x; 
} 

struct Meh { 
    static const int x = 2; 
} 

int main() { 
    std::cout << x; // => 5 
    { 
    int x = 4; 
    std::cout << x; // => 4 
    std::cout << ::x; // => 5, this one looks for x outside the current scope 
    } 
    std::cout << Meh::x; // => 2, use the definition of x inside the scope of Meh 
    std::cout << foo::x; // => 0, use the definition of x inside foo 
    std::cout << bar(); // => 1, use the definition of x inside bar (returned by bar) 
} 

estranei: cout e cin non sono funzioni, ma le istanze di oggetti stream.

EDIT fisso come Keine Lust suggerito