Występy są dokładnie takie same, ponieważ odniesienia są implementowane wewnętrznie jako wskaźniki. Dlatego nie musisz się o to martwić.

Nie ma ogólnie przyjętej konwencji dotyczącej tego, kiedy używać odniesień i wskaźników. W kilku przypadkach musisz zwrócić lub zaakceptować referencje( na przykład Konstruktor kopiujący), ale poza tym możesz robić, co chcesz. Dość powszechną konwencją, z którą się spotkałem, jest używanie referencji, gdy parametr musi odnosić się do istniejącego obiektu i wskaźniki, gdy wartość NULL jest ok.

Niektóre konwencje kodowania (jak Google ' s) zalecają, że należy zawsze używać wskaźników lub odniesień const, ponieważ odniesienia mają nieco niejasną składnię: mają zachowanie odniesienia, ale składnię wartości.

From C++ FAQ Lite -

Używaj referencji, gdy możesz, i wskaźników, gdy musisz.

Odniesienia są zwykle preferowane niż wskaźniki, gdy nie potrzebujesz "reseating" Zazwyczaj oznacza to, że odniesienia są najbardziej przydatne w publiczny interfejs klasy. Odniesienia zazwyczaj pojawiają się na skórze obiekt i wskaźniki w środku.

Wyjątkiem od powyższego jest miejsce, w którym parametr funkcji lub powrót wartość potrzebuje " sentinel" reference - odniesienie, które nie odnosi się do obiektu. Zwykle najlepiej jest to zrobić, zwracając / biorąc wskaźnik, i nadanie wskaźnika NULL tego szczególnego znaczenia (odwołania muszą zawsze aliasy obiektów, a nie dereferenced wskaźnik NULL).

Uwaga: Programiści starej linii C czasami nie lubią odniesień od zapewniają semantykę odniesienia, która nie jest jednoznaczna w rozmówcy kod. Po pewnym doświadczeniu w C++ szybko jednak zdajemy sobie sprawę, że jest to forma informacji ukrywanie, co jest raczej atutem niż odpowiedzialność. Np. programiści powinni pisać kod w języku problem, a nie Język maszyny.

Moja zasada to:

• Użyj wskaźników dla parametrów wychodzących lub in / out. Więc widać, że wartość zostanie zmieniona. (Musisz użyć &)
• Użyj wskaźników, jeśli parametr NULL jest wartością akceptowalną. (Upewnij się, że jest to const jeśli jest to parametr przychodzący)
• Użyj referencji dla przychodzących parametrów, jeśli nie może być NULL i nie jest typem prymitywnym (const T&).
• Użyj wskaźników lub inteligentnych wskaźników podczas zwracania nowo utworzonego obiektu.
• Użyj wskaźników lub Inteligentne Wskaźniki jako członkowie struktury lub klasy zamiast referencji.
• Użyj odniesień do aliasingu (np. int &current = someArray[i])

Niezależnie od tego, którego z nich używasz, nie zapomnij udokumentować swoich funkcji i znaczenia ich parametrów, jeśli nie są oczywiste.

Jak inni już odpowiedzieli: Zawsze używaj referencji, chyba że zmienna jest NULL/nullptr jest naprawdę ważnym stanem.

Wskaźniki NULL są największym problemem w C / C++, przynajmniej w naszym kodzie. Podwójne użycie pojedynczej wartości zarówno jako flagi, jak i adresu powoduje niewiarygodną liczbę poważnych problemów. Odniesienia do C++ powinny być faworyzowane nad wskaźnikami, gdy tylko jest to możliwe; podczas gdy odniesienie jest "naprawdę" tylko pointer, ma ukrytą umowę, że nie jest-NULL. Wykonuj kontrole NULL, gdy wskaźniki zostaną zamienione w referencje, a następnie możesz zignorować problem.

Http://www.altdevblogaday.com/2011/12/24/static-code-analysis/

Edycja 2012-03-13

User Bret Kuhns ]}

Standard C++11 został sfinalizowany. Myślę, że nadszedł czas w tym wątku, aby wspomnieć, że większość kodu powinna radzić sobie doskonale z połączenie referencji, shared_ptr i unique_ptr.

To prawda, ale wciąż pozostaje pytanie, nawet przy zastępowaniu wskaźników surowych wskaźnikami inteligentnymi.

Na przykład, zarówno std::unique_ptr jak i std::shared_ptr mogą być skonstruowane jako" puste " wskaźniki za pomocą domyślnego konstruktora:

• http://en.cppreference.com/w/cpp/memory/unique_ptr/unique_ptr
• http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr

... oznacza to, że używanie ich bez sprawdzania, czy nie są puste, grozi awarią, o co dokładnie chodzi w dyskusji J. Carmacka.

A potem mamy zabawny problem " jak przekazać inteligentny wskaźnik jako parametr funkcji?"

Jon'S odpowiada na pytanie C++ - przekazywanie referencji do boost:: shared_ptr, A poniższe komentarze pokazują, że nawet wtedy przekazywanie inteligentnego wskaźnika przez kopię lub przez odniesienie nie jest tak jasne, jak można by jak (preferuję sobie domyślnie "by-reference", ale mogę się mylić).

Zastrzeżenie: poza tym, że odniesienia nie mogą być NULL ani "rebound" (co oznacza, że nie mogą zmienić obiektu, którego są aliasem), to naprawdę sprowadza się do kwestii gustu, więc nie powiem "to jest lepsze".

add_one(&a);

Może być jaśniejsze niż

add_one(a);

Ponieważ wiesz, że najprawdopodobniej wartość a będzie zmiana. Z drugiej jednak strony, podpis funkcji

void add_one(int* const n);

Nie jest też jasne: czy n będzie pojedynczą liczbą całkowitą czy tablicą? Czasami masz dostęp tylko do (słabo udokumentowanych) nagłówków i podpisów, takich jak

foo(int* const a, int b);

Imho, odniesienia są tak dobre jak wskaźniki, gdy nie jest potrzebna (re)alokacja ani rebinding (w sensie wyjaśnionym wcześniej). Ponadto, jeśli programista używa tylko wskaźników dla tablic, podpisy funkcji są nieco mniej niejednoznaczne. Nie wspominając już o tym, że składnia operatorów jest o wiele bardziej czytelna z referencjami.

To nie jest kwestia gustu. Oto kilka ostatecznych zasad.

Jeśli chcesz odwołać się do statycznie zadeklarowanej zmiennej w zakresie, w którym została zadeklarowana, użyj referencji C++, a będzie to całkowicie bezpieczne. To samo dotyczy statycznie deklarowanego inteligentnego wskaźnika. Przykładem takiego zastosowania jest przekazywanie parametrów przez odniesienie.

Jeśli chcesz odwołać się do czegokolwiek z zakresu, który jest szerszy niż zakres, w którym jest zadeklarowany, powinieneś użyć odniesienia policzyłem inteligentny wskaźnik, aby był całkowicie bezpieczny.

Można odwoływać się do elementu kolekcji z odniesieniem dla wygody składniowej, ale nie jest to bezpieczne; element można usunąć w dowolnym momencie.

Aby bezpiecznie trzymać odniesienie do elementu kolekcji, musisz użyć inteligentnego wskaźnika z liczeniem odniesień.

Każda różnica w wydajności byłaby tak mała, że nie uzasadniałaby zastosowania mniej wyraźnego podejścia.

Po pierwsze, jeden przypadek, który nie został wymieniony, gdzie odniesienia są ogólnie lepsze, to const odniesienia. W przypadku typów nieprostych podanie const reference unika tworzenia tymczasowej i nie powoduje zamieszania, o które się martwisz (ponieważ wartość nie jest modyfikowana). Tutaj, zmuszanie osoby do podania wskaźnika powoduje bardzo zamieszanie, o które się martwisz, ponieważ widząc adres wzięty i przekazane do funkcji może sprawić, że pomyślisz, że wartość się zmieniła.

Kiedy musisz zwrócić wartość w typie złożonym, preferuję referencje. Na przykład:

bool GetFooArray(array &foo); // my preference
bool GetFooArray(array *foo); // alternative

Tutaj, nazwa funkcji wyjaśnia, że otrzymujesz informacje z powrotem w / align = "left" / Więc nie ma żadnego zamieszania.

Główne zalety referencji to to, że zawsze zawierają poprawną wartość, są czystsze niż wskaźniki i wspierają polimorfizm bez potrzeby dodatkowej składni. Jeśli żadna z tych zalet nie ma zastosowania, nie ma powodu, aby preferować odniesienie niż wskaźnik.

Skopiowane z wiki -

Konsekwencją tego jest to, że w wielu implementacjach operowanie zmienną o automatycznym lub statycznym czasie życia poprzez odniesienie, choć składniowo podobne do bezpośredniego dostępu do niego, może wiązać się z ukrytymi operacjami dereferencji, które są kosztowne. Odwołania są składniowo kontrowersyjną cechą C++, ponieważ zaciemniają poziom indrection identyfikatora; to znaczy, w przeciwieństwie do kodu C, w którym wskaźniki zwykle wyróżniają się składniowo, w duży blok kodu C++ może nie być od razu oczywiste, czy dany obiekt jest zdefiniowany jako zmienna lokalna lub globalna lub czy jest to odniesienie (wskaźnik Ukryty) do innej lokalizacji, zwłaszcza jeśli kod łączy odwołania i wskaźniki. Ten aspekt może sprawić, że źle napisany kod C++ będzie trudniejszy do odczytania i debugowania (zobacz Aliasing).

Zgadzam się w 100% z tym, i dlatego uważam, że należy używać odniesienia tylko wtedy, gdy masz bardzo dobry powód, aby to zrobić.

Występuje problem z regułą " użyj odniesień tam, gdzie to możliwe " i pojawia się, jeśli chcesz zachować odniesienie do dalszego użycia. Aby zilustrować to na przykładzie, wyobraź sobie, że masz następujące klasy.

class SimCard
{
    public:
        explicit SimCard(int id):
            m_id(id)
        {
        }

        int getId() const
        {
            return m_id;
        }

    private:
        int m_id;
};

class RefPhone
{
    public:
        explicit RefPhone(const SimCard & card):
            m_card(card)
        {
        }

        int getSimId()
        {
            return m_card.getId();
        }

    private:
        const SimCard & m_card;
};

Na początku może się wydawać, że dobrym pomysłem jest przekazanie parametru w konstruktorze RefPhone(const SimCard & card) przez referencję, ponieważ zapobiega to przekazywaniu błędnych / null wskaźników do konstruktora. W jakiś sposób zachęca do alokacji zmiennych na stos i czerpania korzyści z RAII.

PtrPhone nullPhone(0);  //this will not happen that easily
SimCard * cardPtr = new SimCard(666);  //evil pointer
delete cardPtr;  //muahaha
PtrPhone uninitPhone(cardPtr);  //this will not happen that easily

RefPhone tempPhone(SimCard(666));   //evil temporary
//function referring to destroyed object
tempPhone.getSimId();    //this can happen

Więc jeśli ślepo trzymasz się referencji, wymieniasz możliwość przekazywania nieprawidłowych wskaźników na możliwość przechowywania referencji do zniszczonych obiektów, co ma zasadniczo taki sam efekt.

Edit: zauważ, że przykleiłem się do reguły " używaj referencji gdziekolwiek możesz, wskaźników gdziekolwiek musisz. Unikaj wskazówek, dopóki nie możesz. " z najbardziej upvoted i akceptowane odpowiedzi (inne odpowiedzi również zasugeruj tak). Chociaż powinno to być oczywiste, przykładem nie jest pokazywanie, że odniesienia jako takie są złe. Mogą być jednak nadużywane, podobnie jak wskaźniki i mogą wnieść własne zagrożenia do kodu.

Istnieją następujące różnice między wskaźnikami i odniesieniami.

1. jeśli chodzi o przekazywanie zmiennych, pass by reference wygląda jak pass by value, ale ma semantykę wskaźnika (działa jak wskaźnik).
2. odniesienie nie może być bezpośrednio inicjowane na 0 (null).
3. Reference (reference, not referenced object) nie może być modyfikowany (odpowiednik wskaźnika "* const").
4. const reference może przyjmować tymczasowy parametr.
5. lokalne odniesienia const przedłużają żywotność obiektów tymczasowych

Biorąc pod uwagę moje obecne zasady są następujące.

• użyj odniesień do parametrów, które będą używane lokalnie w funkcji zakres.
• użyj wskaźników, gdy 0 (null) jest akceptowalną wartością parametru lub musisz zapisać parametr do dalszego użycia. Jeśli 0 (null) jest dopuszczalne dodaję do parametru przyrostek "_n", użyj strzeżonego wskaźnika (jak QPointer w Qt) lub po prostu go udokumentuj. Możesz również użyć inteligentnych wskaźników. musisz być jeszcze bardziej ostrożny ze współdzielonymi wskaźnikami niż ze zwykłymi wskaźnikami (w przeciwnym razie możesz skończyć z przeciekami pamięci i bałaganem odpowiedzialności).

Oto kilka wskazówek.

Funkcja wykorzystuje przekazane dane bez ich modyfikacji:

1. Jeśli obiekt danych jest mały, np. Wbudowany typ danych lub mała struktura, przekaż go przez wartość.

2. Jeśli obiekt data jest tablicą, użyj wskaźnika, ponieważ jest to jedyny wybór. Uczyń wskaźnik wskaźnikiem do const.

3. Jeśli obiekt danych jest strukturą o dużych rozmiarach, użyj wskaźnika const lub const odniesienie do programu zwiększenia wydajność.Oszczędzasz czas i miejsce potrzebne do skopiuj strukturę lub projekt klasy. Stwórz wskaźnik lub referencję const.

4. Jeśli obiekt data jest obiektem klasy, użyj referencji const.Semantyka projektowania klas często wymaga użycia referencji, co jest głównym powodem, dla którego C++ dodał ta funkcja.Tak więc, standardowym sposobem przekazywania argumentów obiektu klasy jest Referencja.

Funkcja modyfikuje dane w funkcji wywołującej:

1.Jeśli obiekt danych jest Wbudowany typ danych, użyj wskaźnika. Jeśli zauważysz kod podobnie jak fixit (&x), gdzie x jest int, jest całkiem jasne, że ta funkcja zamierza zmodyfikować x.

2.Jeśli obiekt danych jest tablicą, użyj tylko swojego wyboru: wskaźnika.

3.Jeśli obiekt danych jest strukturą, użyj odniesienia lub wskaźnika.

4.Jeśli obiekt data jest obiektem klasy, użyj referencji.

Oczywiście, są to tylko wytyczne i mogą być powody, dla których można inaczej wybory. Na przykład cin używa odniesienia do podstawowych typów, dzięki czemu można używać cin > > n zamiast cin > > &n.

Punkty do zapamiętania:

1. Wskaźniki mogą być NULL, referencje nie mogą być NULL.

2. Referencje są łatwiejsze w użyciu, const mogą być używane jako referencje, gdy nie chcemy zmieniać wartości i potrzebujemy tylko referencji w funkcji.

3. Wskaźnik używany z *, podczas gdy odniesienia używane z &.

4. Użyj wskaźników, gdy wymagana jest operacja arytmetyczna wskaźnika.

5. Możesz mieć wskazówki do typ void int a=5; void *p = &a;, ale nie może mieć odniesienia do typu void.

Pointer Vs Reference

void fun(int *a)
{
    cout<<a<<'\n'; // address of a = 0x7fff79f83eac
    cout<<*a<<'\n'; // value at a = 5
    cout<<a+1<<'\n'; // address of a increment by 4 bytes(int) = 0x7fff79f83eb0
    cout<<*(a+1)<<'\n'; // value here is by default = 0
}
void fun(int &a)
{
    cout<<a<<'\n'; // reference of original a passed a = 5
}
int a=5;
fun(&a);
fun(a);

Werdykt kiedy używać co

Pointer: dla array, linklist, implementacji drzewa i arytmetyki wskaźników.

Reference: in function parameters and return types.

Tylko wkładam kasę. Właśnie wykonałem test. A to kichacz. Po prostu pozwalam g++ tworzyć pliki assembly tego samego mini-programu za pomocą wskaźników w porównaniu z używaniem referencji. Patrząc na wyjście są dokładnie takie same. Poza symbolem. Więc patrząc na wydajność (w prostym przykładzie) nie ma problemu.

Teraz w temacie wskaźniki vs referencje. IMHO myślę, że clearity stoi ponad wszystkim. Jak tylko przeczytałem Ukryte zachowanie moje palce zaczynają się zwijać. I zgadzam się, że to miłe Ukryte zachowanie, że odniesienie nie może być NULL.

Dereferencja wskaźnika NULL nie jest problemem. spowoduje to awarię aplikacji i będzie łatwe do debugowania. Większym problemem są niezaliczane wskaźniki zawierające nieprawidłowe wartości. Najprawdopodobniej spowoduje to uszkodzenie pamięci powodujące nieokreślone zachowanie bez wyraźnego pochodzenia.

Tutaj myślę, że odniesienia są znacznie bezpieczniejsze niż wskaźniki. I zgadzam się z poprzednim stwierdzeniem, że interfejs (co powinno być jasno udokumentowane, patrz projekt przez kontrakt, Bertrand Meyer) definiuje wynik parametrów do funkcji. Teraz biorąc to wszystko pod uwagę moje preferencje przejdź do korzystanie z referencji w miarę możliwości.

Ogólnie zmienna członkowska nigdy nie powinna być referencją, ponieważ nie ma w tym sensu. Powoduje to, że klasa nie może być przypisana, jeśli nie podasz operatora przypisania. Również po ustawieniu odniesienia do członka, aby odnosić się do jakiegoś obiektu, nie można zmienić tego członka, aby odnosił się do innego obiektu. Najbardziej odpowiednim zastosowaniem odniesienia jest użycie jako parametru funkcji, który umożliwia przejście przez odniesienie.

Referencje są czystsze i łatwiejsze w użyciu, a także lepiej ukrywają informacje. Nie można jednak przypisać odniesień. Jeśli musisz najpierw wskazać jeden obiekt, a następnie inny, musisz użyć wskaźnika. Referencje nie mogą być null, więc jeśli istnieje jakakolwiek szansa, że dany obiekt może być null, nie wolno używać referencji. Musisz użyć wskaźnika. Jeśli chcesz samodzielnie obsługiwać manipulację obiektami, tzn. jeśli chcesz przydzielić miejsce w pamięci dla obiektu na stercie raczej na stosie musisz użyć Pointer

int *pInt = new int; // allocates *pInt on the Heap

Dla wskaźników, trzeba je wskazać na coś, więc wskaźniki kosztować miejsce w pamięci.

Na przykład funkcja, która pobiera wskaźnik liczby całkowitej, Nie pobierze zmiennej liczby całkowitej. Musisz więc najpierw utworzyć wskaźnik, aby przekazać go do funkcji.

Jeśli chodzi o odniesienie, nie będzie kosztować pamięci. Masz zmienną całkowitą i możesz przekazać ją jako zmienną referencyjną. To wszystko. Nie musisz tworzyć zmiennej referencyjnej specjalnie dla niej.

Wolę używać wskaźników. Przynajmniej jest jasne, co robisz. Mam wrażenie, że odniesienia są używane głównie ze względu na STL i jego wpływ na składnię kodu. Z tego powodu wiele nowości w bibliotekach C++, takich jak std:: move ..... aby uzyskać dokładnie to, czego chcesz, a nie to, o czym intuicyjnie byś pomyślał.

Użyj odniesień jako ostateczności. Przydziel instancję na stosie lub stercie, użyj ich.

Użyj referencji dla zakresu parametru, aby uzyskać najmniejszy wpływ. Jeśli używasz referencji, ponieważ wskaźniki są dla Ciebie zbyt trudne, przejdź do innego języka.