Dev Faq
0
votes

La fonction make C ++ renvoie un fichier croisé de tableau

Je cherche à faire en sorte qu'une fonction renvoie un tableau de taille définie et assigne la valeur de ce tableau à un autre tableau. La fonction est située dans un fichier et le tableau auquel je vais attribuer sa valeur de retour est situé dans un autre.

J'essaye de faire cela dans un projet SFML. Chaque fois que j'appelle la fonction de tableau, mon programme se fige et cesse de répondre.

generate_maze.cpp:

char* generate_maze();

extrait de main.cpp: 

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <SFML/Graphics.hpp>

#include "controls.h"
#include "generate_maze.h"

...

char* maze = generate_maze();
std::cout << (int) maze[0] << std::endl;

generate_maze.h : 

#include <SFML/Graphics.hpp>
#include "generate_maze.h"

char* generate_maze() {

    char test_maze[169] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
    0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };

    return test_maze;

}

Merci d'avance pour l'aide.

2 commentaires

vous recherchez std :: array

Votre fonction generate_maze renvoie un pointeur vers une variable allouée sur la pile, test_maze . Ce comportement n'est pas défini, car la durée de vie de test_maze est seulement aussi longue que la fonction englobant sa définition. Plusieurs solutions: l'allouer sur le tas, le rendre statique, le rendre global, etc.

3 Réponses :

0
votes

generate_maze renvoie l'adresse de test_maze [0] , qui est une variable locale. Vous ne devriez jamais renvoyer des adresses de (ou des références à) des variables locales à partir d'une fonction.

Allouez le labyrinthe sur le tas à la place et renvoyez cela: 

std::vector<char> generate_maze() {
    return {0, 0, 0, ...};
}

Alternativement, juste renvoie un std :: vector qui fait sa propre gestion de la mémoire. 

char* generate_maze() {
    char local[] = {
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
    0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
    char* ret = new char[sizeof local];

    memcpy(ret, local, sizeof local);

    return ret;
}

0 commentaires
0
votes

generate_maze () renvoie le pointeur sur la matrice locale, qui est détruite lorsque la fonction est sortie. de
Pour résoudre ce problème, vous pouvez définir test_maze statique: Static Char Test_Maze [] .

Cela créera une matrice permanente pour tous les appels de fonction generaze_maze () . Si vous allez mettre en place generate_maze () pour renvoyer différentes matrices de labyrinthes, meilleure utilisation std :: vecteur ou std :: tableau .

0 commentaires
3
votes

Le code ne fonctionne pas car generate_maze () renvoie un pointeur vers une variable locale, qui est détruite en quittant la fonction. Pour le faire fonctionner, on pourrait concevoir generate_maze () pour allouer un tableau de char via new , puis les tableau survit après la fin de generate_maze () . Mais cela exigerait aussi de libérer explicitement la mémoire, après que char * maze ne soit plus utilisé.

Une solution bien meilleure c ++ - like est la suivante. Si la taille du tableau est fixe, vous devriez mieux utiliser std :: array pour stocker le résultat de generate_maze () , comme: 

#include <vector>
std::vector<char> generate_maze();

Si la taille du tableau retourné par generate_maze () n'est pas fixe, la bonne manière est d'utiliser std :: vector et de déclarer generate_maze () comme 

#include <array> 

std::array<char, 169> generate_maze() {

    return { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
    0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
    0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
    0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
    0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
    0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
    };
}

1 commentaires

Merci pour la solution.

Articles qui pourrait vous intéresser :

Empilez plusieurs colonnes en une sans ignorer les cellules vides
Recherche du nombre de doublons uniquement et uniquement à la fin d'un tableau numpy
JS: filtre le tableau d'objets par valeur maximale par catégorie
Faire pivoter les éléments d'un tableau