Multidimensionnelle de taille variable tableau en C++

salut, je veux faire quelque chose comme ceci:

int op(string s1, string s2){
    int x = s1.size();
    int y = s2.size();
    int matrix = new int[x][y]
    /* do stuff with matrix */
}

Pour une raison que j'obtiens les erreurs suivantes:

SuperString.cpp(69) : error C2540: non-constant expression as array bound
SuperString.cpp(69) : error C2440: 'initializing' : cannot convert from 'int (*)[1]' to 'int'
        This conversion requires a reinterpret_cast, a C-style cast or function-style cast
SuperString.cpp(71) : error C2109: subscript requires array or pointer type

Merci!

Il vient probablement de C# où est ce qu'il fait est légal 🙂
Il existe déjà de nombreuses questions à ce sujet à partir d'un certain nombre de différents angles (à noter que certains seront marqués [c] parce que le c++ obtient son tableau de comportement à partir de c).
Quelques liens: stackoverflow.com/questions/365782/... et stackoverflow.com/questions/1285457/2d-arrays-with-c et ...
Créer une Matrice clas, voir parashift.com/c++-faq-lite/opérateur-la surcharge.html#faq-13.10

OriginalL'auteur SuperString | 2009-12-22

  1. 24

    Voici un résumé de comment construire un tableau 2d en C++ à l'aide de diverses techniques.

    Statique 2D Matrice:

    const size_t N = 25; //the dimension of the matrix

int matrix[N][N]; //N must be known at compile-time.
//you can't change the size of N afterwards

for(size_t i = 0; i < N; ++i)
{
    for(size_t j = 0; j < N; ++j)
    {
        matrix[i][j] = /* random value! */;
    }
}

    Dynamique Matrice 2d:

    const size_t N = 25; //the dimension of the matrix
int** matrix = new int*[N]; //each element is a pointer to an array.

for(size_t i = 0; i < N; ++i)
    matrix[i] = new int[N]; //build rows

for(size_t i = 0; i < N; ++i)
{
    for(size_t j = 0; j < N; ++j)
    {
        matrix[i][j] = /* random value! */;
    }
}

//DON'T FORGET TO DELETE THE MATRIX!
for(size_t i = 0; i < N; ++i)
    delete matrix[i];

delete matrix;

    Matrice en utilisant std::vector:

    //Note: This has some additional overhead
//This overhead would be eliminated once C++0x becomes main-stream ;)
//I am talking about r-value references specifically.
typedef vector< vector<int> > Matrix;
typedef vector<int> Row;

const size_t N = 25; //the dimension of the matrix
Matrix matrix;

for(size_t i = 0; i < N; ++i)
{
    Row row(N);

    for(size_t j = 0; j < N; ++j)
    {
        row[j] = /* random value! */;
    }

    matrix.push_back(row); //push each row after you fill it
}

//Once you fill the matrix, you can use it like native arrays
for(size_t i = 0; i < N; ++i)
{
    for(size_t j = 0; j < N; ++j)
    {
        cout << matrix[i][j] << " ";
    }

    cout << endl;
}

    Matrice 3d à l'aide de boost::multi_array (prises de boost multi_array docs):

    //Note that this is much more efficient than using std::vector!
int 
main () {
  //Create a 3D array that is 3 x 4 x 2
  typedef boost::multi_array<double, 3> array_type;
  typedef array_type::index index;
  array_type A(boost::extents[3][4][2]);

  //Assign values to the elements
  int values = 0;
  for(index i = 0; i != 3; ++i) 
    for(index j = 0; j != 4; ++j)
      for(index k = 0; k != 2; ++k)
        A[i][j][k] = values++;

  //Verify values
  int verify = 0;
  for(index i = 0; i != 3; ++i) 
    for(index j = 0; j != 4; ++j)
      for(index k = 0; k != 2; ++k)
        assert(A[i][j][k] == verify++);

  return 0;
}
    +1 pour la perfection 🙂
    Le std::vector exemple semble incorrect. Après la Matrix matrix(N) déclaration, matrix a 25 lignes vides. Puis vous appuyez sur 25 plus les lignes non vides, et se termine avec 50 lignes.
    yep, vous êtes tout à fait correcte. J'ai édité la réponse, merci 🙂

    OriginalL'auteur AraK

  2. 4

    Vous devez déclarer la matrice var comme int* matrix, comme un tableau dynamique est déclaré comme un pointeur. Mais vous ne pouvez pas faire un tableau 2d dans une nouvelle avec les deux dimensions étant variable. Vous pouvez faire un tableau 1D et ne l'indexation de mathématiques sur votre propre.

    int* matrix = new int[x*y];
    //Set element x1,y1 to 5
    matrix[x1+y1*x] = 5;

    Ok. Et puis quoi?
    C'est tableau 2d en question, et int* ne fonctionne pas
    Lire attentivement la question.
    un tableau est un pointeur" n'est pas correct. Tableau est un "tableau", il peut être converti en un type pointeur chaque fois que nécessaire, par exemple en passant d'un tableau à une fonction, tableau dans la fonction d'appel est converti en un type pointeur comme argument formel dans la fonction appelée.
    ouais j'ai lu l'avertissement du compilateur et a raté la 2d partie quand j'ai répondu.

    OriginalL'auteur Zanson

  3. 3

    Utilisation boost::multi_array.
    Voir le doc et cette question pour plus de détails.

    Qui va vous aider à éviter beaucoup d'erreurs.

    OriginalL'auteur Klaim

  4. 2

    Si la taille de matrix n'a pas besoin de passer par la fonction, vous pouvez déclarer le ints le stockage de la string longueur const. Cela vous permet de créer un tableau multidimensionnel dont la taille peut varier pour chaque appel de fonction, mais conserve une taille constante pendant toute la durée de la fonction.

    #include <iostream>
#include <string>

using namespace std;

int someFunc(string, string);

int someFunc(string s1, string s2)
{
    const int x = s1.length();
    const int y = s2.length();

    int matrix[x][y];
    int result=0;

    for(int i=0;i<x;i++)
        for(int j=0;j<y;j++)
            matrix[i][j]=i*j;

    for(int i=0;i<x;i++)
        for(int j=0;j<y;j++)
            result+=matrix[i][j];

    return result;
}

int main()
{
    string s1 = "fubar";
    string s2 = "somethingelse";

    cout<<someFunc(s1,s2)<<endl;
}

    EDIT: Sur la lecture de l'une des autres réponses posté pendant que j'écrivais le mien, je suppose que vous devez utiliser const size_t au lieu de const int. Désolé, mon C++ est juste un peu rouillé.

    OriginalL'auteur Chinmay Kanchi

  5. 0

    Vous ne pouvez pas avoir une matrice de non-constante de la taille de la ligne.

    Vous pouvez choisir "tableau de pointeurs vers des tableaux" de la structure qui peut être indexé comme pp[a][b] tout comme une matrice. Vous ne pouvez pas allouer une telle structure avec un seul new. Vous aurez à construire manuellement dans un tampon.

    OriginalL'auteur Pavel Radzivilovsky

  6. -2

    C'est plus un problème de syntaxe.

    Dernière vérification dans gcc 4.4, int matrix[x][y]; semble fonctionner comme prévu. Si votre tableau n'avez pas besoin de redimensionnement dans le milieu de la fonction. Vous pouvez essayer cette syntaxe et voir si cela fonctionne dans votre compilateur.

    OriginalL'auteur billyswong