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或

内部链接

在内联函数中使用本地静态（有效支持外部链接），或
使用一点模板技巧（也支持外部链接）。

最后两个解决方案是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;
}

干杯＆amp;第h。，

Answer 5

你可以这样做：

标题

中的

extern int lettersArr[26];

in .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 6

尝试：

lettersArr = { 1, 2, 3, 4 }

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

6 个答案:

内部联系

内联函数中的局部静态

模板技巧