在 C++ 中声明数组标头并在cpp文件中定义它？

Question

这可能是一件非常简单的事情，但我是 C++ 新手，所以需要帮助。

我只想在我的 C++ 头文件中声明一个数组，例如：

int lettersArr[26];

然后在 cpp 文件中的函数中定义它，例如：

    lettersArr[26] = { letA, letB, letC, letD, letE, letF, letG, letH,
        letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
        letT, letU, letV, letW, letX, letY, letZ };

但这不起作用。

我语法错误还是什么？正确的方法是什么？

多谢。

Answer 1

将 extern 添加到头文件的声明中。

extern int lettersArr[26];

（此外，除非您打算更改数组，否则请考虑添加 const。）

定义必须具有类型。添加 int （或 const int）：

int lettersArr[26] = { letA, /*...*/ };

Answer 2

标题：

extern int lettersArr[];

全局范围内的源：

int lettersArr[26] = { letA, letB, letC, letD, letE, letF, letG, letH,
    letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
    letT, letU, letV, letW, letX, letY, letZ };

或者如果您确实想在函数中执行此操作：

全局范围内的源：

int lettersArr[26];

函数中的源：

int localLettersArr[26] = { letA, letB, letC, letD, letE, letF, letG, letH,
    letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
    letT, letU, letV, letW, letX, letY, letZ };

memcpy (lettersArr, localLettersArr, sizeof (localLettersArr));

Answer 3

将标题中的内容更改为：

extern int lettersArr[26];

，以便它将成为声明，而不是定义。

Answer 4

其他人描述了如何将数组初始化移动到实现文件，这并不能完全回答您的问题，但这是一种值得了解的解决方法。

<块引用>

我只想在我的 C++ 头文件中声明一个数组

如果您确实希望将数组全部放在头文件中，包括在头文件中进行初始化，那么您可以

• 给它内部链接 使用static，或

  使用

• 使用本地内联函数中的 static（支持有效的外部链接），或者

• 使用一点模板技巧（也支持外部链接）。

最后两个解决方案是针对 C++ 中缺少“inline”数据的解决方法。也就是说，能够在多个翻译单元中定义相同的命名空间范围对象。您可以通过 inline 为函数提供此功能，但不幸的是，不适用于对象：如果不采用某些解决方法，链接器只会抗议多个定义。

内部链接

这通常不是一个好的解决方案。它在包含标头的每个翻译单元中创建一个数组。但对于相对较小的 const 对象来说它更可取，因为它非常简单：

#include <stddef.h>
#include <iostream>

int const   letA    = 'A';
int const   letB    = 'B';
int const   letC    = 'C';
int const   letD    = 'D';
int const   letE    = 'E';
int const   letF    = 'F';
int const   letG    = 'G';
int const   letH    = 'H';
int const   letI    = 'I';
int const   letJ    = 'J';
int const   letK    = 'K';
int const   letL    = 'L';
int const   letM    = 'M';
int const   letN    = 'N';
int const   letO    = 'O';
int const   letP    = 'P';
int const   letQ    = 'Q';
int const   letR    = 'R';
int const   letS    = 'S';
int const   letT    = 'T';
int const   letU    = 'U';
int const   letV    = 'V';
int const   letW    = 'W';
int const   letX    = 'X';
int const   letY    = 'Y';
int const   letZ    = 'Z';

static int lettersArr[26]   =
{
    letA, letB, letC, letD, letE, letF, letG, letH,
    letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
    letT, letU, letV, letW, letX, letY, letZ
};

int main()
{
    using namespace std;
    for( int i = 0;  i < 26;  ++i )
    {
        cout << char( lettersArr[i] );
    }
    cout << endl;
}

内联函数中的局部静态

这可能是通常“最佳”的解决方案，当没有选择其他解决方案之一的首要原因时使用。一件好事是很容易提供动态初始化。在这里，我只是假设您永远不会在数组中存储 0（如果该假设不成立，则添加一些额外的检查逻辑）：

#include <stddef.h>
#include <iostream>

template< class Type, int n >
int countOf( Type (&)[n] ) { return n; }

typedef int LettersArray[26];

inline LettersArray& lettersArrayRef()
{
    static LettersArray theArray;

    if( theArray[0] == 0 )
    {
        // Assuming normal ASCII-based character set with contiguous alpha.
        for( int i = 0;  i < countOf( theArray );  ++i )
        {
            theArray[i] = i + 'A';
        }
    }
    return theArray;
}

static LettersArray&    lettersArr  = lettersArrayRef();

int main()
{
    using namespace std;
    for( int i = 0;  i < 26;  ++i )
    {
        cout << char( lettersArr[i] );
    }
    cout << endl;
}

模板技巧

模板技巧之所以有效，是因为标准的 ODR，一个定义规则，对模板进行了特殊豁免：

#include <stddef.h>
#include <iostream>

int const   letA    = 'A';
int const   letB    = 'B';
int const   letC    = 'C';
int const   letD    = 'D';
int const   letE    = 'E';
int const   letF    = 'F';
int const   letG    = 'G';
int const   letH    = 'H';
int const   letI    = 'I';
int const   letJ    = 'J';
int const   letK    = 'K';
int const   letL    = 'L';
int const   letM    = 'M';
int const   letN    = 'N';
int const   letO    = 'O';
int const   letP    = 'P';
int const   letQ    = 'Q';
int const   letR    = 'R';
int const   letS    = 'S';
int const   letT    = 'T';
int const   letU    = 'U';
int const   letV    = 'V';
int const   letW    = 'W';
int const   letX    = 'X';
int const   letY    = 'Y';
int const   letZ    = 'Z';

template< class Dummy >
struct Letters_
{
    static int  array[26];
};

template< class Dummy >
int Letters_< Dummy >::array[26]    =
{
    letA, letB, letC, letD, letE, letF, letG, letH,
    letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
    letT, letU, letV, letW, letX, letY, letZ
};

static int (&lettersArr)[26]    = Letters_<void>::array;

int main()
{
    using namespace std;
    for( int i = 0;  i < 26;  ++i )
    {
        cout << char( lettersArr[i] );
    }
    cout << endl;
}

Cheers &呵呵，

Answer 5

这是我的头文件之一的片段（实现 .cpp 文件访问数组）：
（在虚拟命名空间之外使用 dummy::messages 来访问数组。）

<pre>
    namespace dummy {

const static string messages[] = {
        "Unix does not echo the password field. Why do you think this is?",
        "The firewall blocks external access to ouranos. You need to login to helios and ssh or sftp to ouranos",
        "You need to experience of the command line. Not all systems have a gui.",
};

class Message {
public:
    Message();
    virtual ~Message();

    string getMessage();
    string getMessage( int index );
    int getRandomNumber();
};

} /* namespace dummy */
</pre>

Answer 6

你可以这样做：

标头中

extern int lettersArr[26];

在.cpp 的

int lettersArr[26] = { letA, letB, letC, letD, letE, letF, letG, letH,
        letI, letJ, letK, letL, letM, letN, letO, letP, letQ, letR, letS,
        letT, letU, letV, letW, letX, letY, letZ };

Answer 7

尝试：

lettersArr = { 1, 2, 3, 4 }