C++ 11 dichiarazione automatica con e senza pointer pointer

Question

Qual è la differenza tra i tipi di bar1 e bar2?

int foo = 10; 
auto bar1 = &foo; 
auto *bar2 = &foo; 

Se entrambi bar1 e bar2 sono int*, non ha senso scrivere il dichiaratore puntatore (*) nella dichiarazione bar2?

Answer 1

Le dichiarazioni sono esattamente equivalenti. auto funziona (quasi) come template type deduction. Mettere la stella in modo esplicito rende il codice un po 'più facile da leggere e rende il programmatore consapevole del fatto che bar2 è un puntatore.

Answer 2

Non ha importanza per quanto riguarda l'interpretazione del codice C++; puoi scrivere quello che vuoi Tuttavia, c'è una questione di stile e leggibilità: in generale, non devi nascondere i qualificatori di puntatori, riferimenti e CV, e forse anche i puntatori intelligenti, in alias di tipi, poiché rende più difficile per il lettore capire che è ciò che sta accadendo. Gli alias di tipo dovrebbero includere il contenuto di tipo semanticamente rilevante, mentre i qualificatori e i modificatori dovrebbero rimanere visibili. Così preferiscono la seguente:

using Foo = long_namespace::Foobrigation<other_namespace::Thing>; 
using MyFn = const X * (int, int); 

std::unique_ptr<Foo> MakeThatThing(MyFn & fn, int x) // or "MyFn * fn" 
{ 
    const auto * p = fn(x, -x); 
    return p ? p->Create() : nullptr; 
} 

E non dire:

using PFoo = std::unique_ptr<Foo>; // just spell it out 
using MyFn = int(&)(int, int);  // unnecessary; & is easy to spell 
auto p = fn(x, -x);     // Don't know that p is a pointer 

Si noti inoltre che le qualificazioni di riferimento (a differenza di puntatori) cambiare veramente il tipo di variabile che viene dichiarato, quindi non sono facoltativo:

X & f(); 
auto a = f(); // copy! 
auto & b = f(); // b is the same as the return value of f() 

Infine, l'aggiunta di qualifiche esplicite del puntatore const può essere d'aiuto nella cost-correttezza. Considera il prossimo esempio, in cui un contenitore contiene puntatori a mutevole, ma abbiamo solo bisogno dell'accesso const. Basta auto * sarebbe dedurre un puntatore ad mutevole, che possiamo evitare dicendo const esplicitamente:

std::vector<X*> v = /* ... */; 
for (const auto * p : v) 
{ 
    observe(p->foo()); // no need for a mutable *p 
} 

Answer 3

In questo esempio specifico sia bar1 e bar2 sono gli stessi. È una questione di preferenze personali, anche se direi che bar2 è più facile da leggere.

Tuttavia, questo non vale per i riferimenti come si vede in questo example:

#include <iostream> 
using namespace std; 

int main() { 
    int k = 10; 
    int& foo = k; 
    auto bar = foo; //value of foo is copied and loses reference qualifier! 
    bar = 5; //foo/k won't be 5 
    cout << "bar : " << bar << " foo : " << foo << " k : " << k << endl; 
    auto& ref = foo; 
    ref = 5; // foo/k will be 5 
    cout << "bar : " << bar << " foo : " << foo << " k : " << k; 
    return 0; 
} 

Answer 4

Utilizzando auto * "documenti intenzione". E auto *p = expr; può essere dedotto correttamente solo se expr restituisce il puntatore. Esempio:

int f(); 

auto q = f(); // OK 

auto *p = f(); // error: unable to deduce 'auto*' from 'f()' 

Answer 5

Come altri hanno detto, genereranno lo stesso codice. L'asterisco è il rumore di linea (e rende più difficile passare da puntatori grezzi a puntatori intelligenti se, ad esempio,viene sostituito da &foo). Se vuoi essere esplicito, allora con tutti i mezzi, essere esplicito; ma quando si utilizza l'inferenza di tipo, lascia che il compilatore faccia il suo lavoro. La mancanza di asterischi non implica che un oggetto non sia un puntatore.

Answer 6

C'è una grande differenza quando si utilizza const qualificazioni:

int i; 

// Const pointer to non-const int 
const auto ip1 = &i; // int *const 
++ip1; // error 
*ip1 = 1; // OK 

// Non-const pointer to const int 
const auto* ip2 = &i; // int const* 
++ip2; // OK 
*ip2 = 1; // error