是否可以传递 std::array 的引用

Is it possible to pass a reference of std::array?

本文关键字：array 引用 std 是否      更新时间：2023-10-16

所以我正在尝试编写一个函数来更改它之外的数组，有点像将值传递给函数作为引用。这是我的代码：

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（） 来初始化 Deck（），它可以很好地打印所有卡片，但它不会存储在 main（） 的原始数组中。

执行此操作时出现此错误;

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

提前感谢！提前感谢！

您需要传递 deck 作为引用，以便函数的外部进行更改。 即代码应该是

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

该主题的轻微扩展，但如果您愿意，您可以在编译时生成您的甲板： （此示例需要 C++14，但 C++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;
}
相关文章：