Déclarer tableau en-tête C++ et de la définir dans un fichier cpp?

En-tête:

extern int lettersArr[];

Source à l'étendue globale:

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 };

ou si vous voulez vraiment faire dans une fonction:

Source étendue globale:

int lettersArr[26];

Source:

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));

D'autres ont décrit comment l'initialisation de tableau peut être déplacé vers un fichier de mise en oeuvre, ce qui n'est pas exactement répondre à votre question, mais c'est une solution de contournement qui est utile à savoir.

Je veux juste déclarer un tableau dans mon en-tête C++ fichier

Si vous voulez vraiment avoir la matrice de tous dans votre fichier d'en-tête, y compris l'initialisation dans votre fichier d'en-tête, alors vous pouvez

• donner liaison interne en utilisant static, ou

• utiliser un statique locale dans une fonction inline (qui soutient efficacement liaison externe), ou

• utiliser un peu de modèle de truc (prend également en charge une liaison externe).

Les deux dernières solutions sont des solutions de contournement pour le manque de "inline" données en C++. Qui est, la capacité de définir le même espace de noms d'objet de l'étendue dans plus d'une unité de traduction. Vous avez que pour les fonctions, via inline, mais malheureusement pas pour les objets: sans employant une solution de contournement que l'éditeur de liens juste pour dénoncer les multiples définitions.

Liaison interne

Ce n'est généralement pas une bonne solution. Il crée un tableau dans chaque unité de traduction où l'en-tête est inclus. Mais il est préférable pour les relativement petites const objets, car c'est si simple:

#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;
}

Locale statique en fonction inline

C'est probablement la généralement de la "meilleure" solution, à utiliser quand il n'y a pas de raison impérieuse pour sélectionner l'une des autres solutions. Une bonne chose est qu'il est facile de fournir des dynamiques de l'initialisation. Ici, j'ai simplement supposé que vous n'aurez jamais stocker 0 dans le tableau (ajoutent de la logique de la vérification si cette hypothèse ne tient pas):

#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;
}

Modèle astuce

Le modèle astuce fonctionne parce que la norme de ODR, Une Définition de la Règle, fait une exemption spéciale pour les modèles:

#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 & hth.,

Voici un extrait de l'un de mes fichiers d'en-tête (la mise en œuvre .fichier cpp accède au tableau):
(Utiliser mannequin::les messages à l'extérieur de la maquette de l'espace de noms pour accéder au tableau.)

<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>