length - Declare array en el encabezado de C++ y defínalo en un archivo cpp?

string array c++

Question

Probablemente esto sea algo realmente simple, pero soy nuevo en C ++, así que necesito ayuda.

Solo quiero declarar una matriz en mi archivo de encabezado de C ++ como:

int lettersArr[26];

y luego definirlo en una función en el archivo cpp como:

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

pero esto no funciona.

¿Tengo mal la sintaxis o algo así? ¿Cuál es la forma correcta de hacer esto?

Muchas gracias.

Answer 1

Agregue extern a la declaración en el archivo de encabezado.

extern int lettersArr[26];

(Además, a menos que planee cambiar la matriz, considere también agregar const .)

La definición debe tener un tipo. Añadir int (o const int ):

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

Answer 2

Aquí hay un fragmento de uno de mis archivos de encabezado (el archivo de implementación .cpp accede a la matriz): (Use dummy :: messages fuera del espacio de nombres ficticios para acceder a la matriz).

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

Cambia lo que tienes en el encabezado a:

extern int lettersArr[26];

Para que se convierta en una declaración, no en una definición.

Answer 4

Encabezamiento:

extern int lettersArr[];

Fuente en el ámbito global:

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

O si realmente quieres hacerlo en una función:

Fuente a nivel global:

int lettersArr[26];

Fuente en función:

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 5

Otros han descrito cómo la inicialización de la matriz se puede mover a un archivo de implementación, que no responde exactamente a su pregunta, pero es una solución que es útil conocer.

Solo quiero declarar una matriz en mi archivo de encabezado de C ++

Si realmente desea tener la matriz en su archivo de encabezado, incluida la inicialización en su archivo de encabezado, puede

• darle enlace interno mediante el uso de static , o

• utilizar una estática local en una función en línea (que admita enlaces externos efectivos), o

• Usa un truco de plantilla pequeño (también soporta enlaces externos).

Las dos últimas soluciones son soluciones alternativas para la falta de datos "en inline " en C ++. Es decir, la capacidad de definir el mismo objeto de ámbito de espacio de nombres en más de una unidad de traducción. Lo tiene para las funciones, en inline , pero desafortunadamente no para los objetos: sin emplear alguna solución, el enlazador solo protestará por las múltiples definiciones.

Enlace interno

Esto generalmente no es una buena solución. Crea una matriz en cada unidad de traducción donde se incluye el encabezado. Pero es preferible para objetos const relativamente pequeños porque es muy 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;
}

Función estática en línea local

Esta es probablemente la solución generalmente "mejor", para usar cuando no hay una razón fundamental para elegir una de las otras soluciones. Una cosa buena es que es fácil proporcionar inicialización dinámica. Aquí asumo que nunca almacenará 0 en la matriz (agregue un poco de lógica de comprobación adicional si esa suposición no se cumple):

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

Truco de plantilla

El truco de la plantilla funciona porque la ODR estándar, una regla de definición , hace una exención especial para las plantillas:

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

Salud y salud,

Answer 6

Puedes hacerlo de esta manera:

en el encabezado

extern int lettersArr[26];

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

tratar:

lettersArr = { 1, 2, 3, 4 }