Можно ли передать ссылку std :: array?

Question

Итак, я пытаюсь написать функцию, которая изменяет массив вне ее, вроде как передать значение функции в качестве ссылки. Вот мой код:

std::array<Card, 52> deck {}; 
std::array<Card, 52> &deckRef = deck; 

initializeDeck(deckRef); 
printDeck(deckRef); 

и

void initializeDeck(std::array<Card, 52> deck){ 
int16_t cardNumber{0}; 
for(int counterSuit{0}; counterSuit < CardSuit::MAX_SUITS; ++counterSuit) 
{ 
    for(int counterRank{0}; counterRank < CardRank::MAX_RANKS; ++counterRank) 
     { 
      Card card { static_cast<CardRank::CardRank>(counterRank), 
         static_cast<CardSuit::CardSuit>(counterSuit)}; 

      deck[cardNumber] = card; 
      ++cardNumber; 

     } 
}} 

void printDeck(std::array<Card, 52> deck){ 
for(int16_t counter{0}; counter < 52; ++counter) 
    { 
     printCard(deck[counter]); 
    }} 

printDeck печатает мусор, однако если добавить printCard() в initializeDeck(), он печатает все карты просто отлично, однако он не получает хранится в исходном массиве в main().

Я получаю эту ошибку, когда я это делаю;

void initializeDeck(std::array<Card, 52>& deck) 

undefined reference to `initializeDeck(std::array<Card, 52u>)'| 

Заранее благодарен! Спасибо заранее!

Answer 1

Вам необходимо передать колоду в качестве ссылки, чтобы внешняя сторона функции имела свои изменения. т.е. код должен быть

void initializeDeck(std::array<Card, 52>& deck){ 

Answer 2

Незначительное расширение этой темы, но вы можете создать свою колоду во время компиляции, если вы хотите: (этот пример требует C++ 14, но с ++ 11 может сделать это с немного больше работы)

#include <iostream> 
#include <iterator> 
#include <algorithm> 
#include <array> 

enum class Suit { Spades, Diamonds, Clubs, Hearts }; 
std::ostream& operator<<(std::ostream& os, Suit s) { 
    switch (s) { 
     case Suit::Spades: return os << "spades"; 
     case Suit::Diamonds: return os << "diamonds"; 
     case Suit::Clubs: return os << "clubs"; 
     case Suit::Hearts: return os << "hearts"; 
    } 
} 

enum class Rank { Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten, Jack, Queen, King, Ace }; 
std::ostream& operator<<(std::ostream& os, Rank r) { 
    switch (r) { 
     case Rank::Two: return os << "two"; 
     case Rank::Three: return os << "three"; 
     case Rank::Four: return os << "four"; 
     case Rank::Five: return os << "five"; 
     case Rank::Six: return os << "six"; 
     case Rank::Seven: return os << "seven"; 
     case Rank::Eight: return os << "eight"; 
     case Rank::Nine: return os << "nine"; 
     case Rank::Ten: return os << "ten"; 
     case Rank::Jack: return os << "jack"; 
     case Rank::Queen: return os << "queen"; 
     case Rank::King: return os << "king"; 
     case Rank::Ace: return os << "ace"; 
    } 
} 

struct Card { 
    Suit suit; 
    Rank rank; 
}; 

std::ostream& operator<<(std::ostream& os, const Card& c) { 
    return os << c.rank << " of " << c.suit; 
} 

constexpr Card make_card(size_t index) 
{ 
    return Card { 
     static_cast<Suit>(index/13), 
     static_cast<Rank>(index % 13) 
    }; 
} 


using Deck = std::array<Card, 52>; 

template<size_t...Is> 
constexpr Deck generate_deck_impl(std::index_sequence<Is...>) 
{ 
    return { make_card(Is)... }; 
} 

constexpr Deck generate_deck() 
{ 
    return generate_deck_impl(std::make_index_sequence<52>()); 
} 


int main() 
{ 
    using namespace std; 
    auto deck = generate_deck(); 
    std::copy(begin(deck), end(deck), ostream_iterator<Card>(cout, ", ")); 
    cout << endl; 

    random_shuffle(begin(deck), end(deck)); 
    std::copy(begin(deck), end(deck), ostream_iterator<Card>(cout, ", ")); 
    cout << endl; 
}