poblado de matriz int que es una variable miembro

Question

Estoy usando C++ para crear un mapa de teselas para un juego. Mi problema es que quiero llenar una matriz multidimensional de entradas en el constructor del Mapa, pero no está funcionando correctamente. Aquí está mi código en "Map.h" (se eliminó el código irrelevante).

class Map { 

private:  
int mapArray[15][20]; 

}; 

Y mi código de Map.cpp

Map::Map() 
{ 

    mapArray = { 
     { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 }, 
     { 20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39 }, 
     { 40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59 }, 
     { 60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79 }, 
     { 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 }, 
     { 100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119 }, 
     { 120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139 }, 
     { 140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159 }, 
     { 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179 }, 
     { 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199 }, 
     { 200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219 }, 
     { 220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239 }, 
     { 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259 }, 
     { 260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279 }, 
     { 280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299 } 
    }; 


} 

PS. crear el mapArray localmente, dentro de una función miembro usando int mapArray [15] [20] y poblarlo funciona bien, parece que no puedo hacer que se llene en el constructor, con una variable miembro.

PPS. Muy oxidado con C++, por favor sea gentil.

¿Qué estoy haciendo mal?

Gracias, James.

Answer 1

No se pueden usar inicializadores de matriz como ese en un constructor de clase. Los miembros solo se pueden inicializar utilizando la lista de inicializadores. Su mejor opción es cargar estos datos de un archivo o declararlos como estáticos.

class Map 
{ 
private: 
static int mapArray[15][20]; 
/* ... */ 
}; 

A continuación, defina el almacenamiento de la matriz estática en un archivo de origen (.cpp), también conocido como una unidad de traducción:

int Map::mapArray[15][20] = { ... }; 

Answer 2

Puede usar la sintaxis del paréntesis solo para la inicialización.

Cuando se ejecuta su constructor, el miembro de la matriz ya se ha creado.

Answer 3

Solo puede usar la sintaxis del parche si está inicializando el conjunto en la declaración. En tu constructor, no lo eres. Es probable que desee cargar los datos del mapa de un archivo de todos modos en lugar de la codificación difícil.

Answer 4

usted debería ser capaz de hacer algo como esto:

class Map 
{ 
    int mapArray[15][20]; 

    public: 
    Map() : mapArray((int[15][20]) { 
    { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 }, 
    { 20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39 }, 
    { 40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59 }, 
    { 60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79 }, 
    { 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 }, 
    { 100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119 }, 
    { 120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139 }, 
    { 140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159 }, 
    { 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179 }, 
    { 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199 }, 
    { 200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219 }, 
    { 220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239 }, 
    { 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259 }, 
    { 260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279 }, 
    { 280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299 } 
    }) 
    { 
    } 
}; 

Tenga en cuenta que este estilo de inicialización es parte de C99 y puede que no se incluya con su compilador o que no funcione para C++. Trabaja en GCC 4 para mí.

También tenga en cuenta que no compilé este código. Lo adapté para su caso de algún otro código mío que sí funciona.

Answer 5

Desafortunadamente, no hay sintaxis para hacer exactamente eso en C++ para matrices no estáticas de miembros. Puede asignar los valores iniciales a los miembros de la matriz uno por uno, pero eso, por supuesto, es bastante engorroso.

Si los valores de matriz son los mismos en todos los objetos de esa clase, es probable que necesite una matriz de miembros static. Vea la respuesta de Mads entonces.

Si realmente necesita una matriz de miembros no estáticos, lo que significa que desea poder "personalizar" el contenido de la matriz por objeto modificándolo más adelante o inicializándolo de manera diferente, puede intentarlo haciendo esto

class Map { 
    static const int MapArrayInit[15][20]; 
    int MapArray[15][20]; 

public: 
    Map() 
    { 
    assert(sizeof MapArray == sizeof MapArrayInit); // better: STATIC_ASSERT 
    std::memcpy(MapArray, MapArrayInit, sizeof MapArray); 
    // Now you can customize MapArray to your liking 
    } 
}; 

y en uno de los archivos de implementación

const int Map::MapArrayInit = { /* whatever */ }; 

esto requiere memoria adicional para MapArrayInit, pero ya que está separada instatiating un MapArray en cada instancia de Map de todos modos, no es un gran problema.

Si no desea modificar su MapArray después de la inicialización, pero todavía quiere tener varias versiones diferentes de MapArray contenidos en diferentes instancias de `Mapa', puede utilizar el siguiente enfoque

class Map { 
    static const int MapArrayInit1[15][20]; 
    static const int MapArrayInit2[15][20]; 
    static const int MapArrayInit3[15][20]; 
    const int (&MapArray)[15][20]; // or a pointer 

public: 
    Map() : MapArray(MapArrayInit1) /* or 2, or 3 */ 
    { 
    } 
}; 

y en uno de los archivos de implementación

const int Map::MapArrayInit1 = { /* whatever */ }; 
const int Map::MapArrayInit2 = { /* whatever */ }; 
const int Map::MapArrayInit3 = { /* whatever */ }; 

Elija lo que funcione mejor para usted.

Answer 6

Esta es una tarea, no una inicialización. Los inicializadores de llaves simples solo funcionan durante la inicialización. Use la sintaxis literal compuesta, que se asemeja a una conversión de tipo (al agregado que desea inicializar) seguido de un inicializador de llaves.

Map::Map() 
{ 

    mapArray = (int[15][20]) { 
     { 0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19 }, 
     { 20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39 }, 
     { 40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59 }, 
     { 60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79 }, 
     { 80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99 }, 
     { 100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119 }, 
     { 120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139 }, 
     { 140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159 }, 
     { 160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179 }, 
     { 180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199 }, 
     { 200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219 }, 
     { 220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239 }, 
     { 240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259 }, 
     { 260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279 }, 
     { 280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299 } 
    };  
}