Partage
  • Partager sur Facebook
  • Partager sur Twitter

ajout de carctere ?????

Comportement non compréensible d'un fonction

    3 avril 2022 à 11:44:01

    Bonjour j'ai développer une fonction qui me permet de récupérer les non de fichier d'un dossier d'un fichier et d'en sortir un tableau de char** et mais quand je la mais dans un de mes programme elle ne fonctionne plus alors que quand je luis passe les même dossier pour la tester elle fonctionne parfaitement. Es que vous pouvez m'aider svp.

    filarray.c

    #include <stdio.h>
    #include <stdlib.h>
    #include <dirent.h>
    
    #include "filarray.h"
    #include "chararray.h"
    #include "string.h"
    
    //fonctiont pour avoir le nombre de fichier
    int nb_file_in_folder(char* name_folder)
    {
    	int nb_folder = 0;
    	//ouverture du dossier
    	DIR* folder = opendir(name_folder);
    
    	if(folder != NULL)
    	{
    		//gestion du dossier
    		struct dirent* s_folder;
    		
    		//boucle pour lire le dossier
    		while((s_folder = readdir(folder)) != NULL)
    		{	
    			//On ne compte pas les fichier chaché
    			if(s_folder->d_name[0] != '.')
    				nb_folder ++;
    		}
    	}
    	else
    		fprintf(stderr, "Imposible d'ouvrir le fichier %s\n", name_folder);
    
    	
    	closedir(folder);
    	return nb_folder;
    }
    
    //Retoure le plus grand nombre de caractère de fichier
    int max_size_file_in_folder(char* name_folder)
    {
    	int size = 0;
    	DIR* folder = opendir(name_folder);
    
    	if(folder != NULL)
    	{
    		struct dirent* s_folder;
    
    		while((s_folder = readdir(folder)) != NULL)
    		{
    			if(s_folder->d_name[0] != '.')
    			{
    				if(size_str(s_folder->d_name) > size)
    					size = size_str(s_folder->d_name);
    			}
    		}
    
    	}
    	else
    		fprintf(stderr, "Imposible d'ouvrir le fichier %s\n", name_folder);
    
    	
    	closedir(folder);
    	return size;
    }
    
    //Retourne un tableau avec le chemin d'un fichier depuis le dossier mis en parametre
    char** tab_file_name(char* name_folder)
    {
    	//Variable tableau
    	int size_tab = nb_file_in_folder(name_folder);
    	int size_name_folder = 0;
    	char** tab = malloc (sizeof(char*) * size_tab);
    	int i = 0;
    	//Variable dossier
    	DIR* folder = opendir(name_folder);
    
    	//taille de la chaine du nom du dossier
    	size_name_folder = size_str(name_folder);
    
    	//Allocation des case du tableau 
    	for(int i = 0; i < size_tab; i++)
    		tab[i] = malloc(sizeof(char) * size_name_folder);
    	
    
    	//Parcour du dossier pour récuperer les noms de fichier
    	if(folder != NULL)
    	{
    		//gestion du dossier
    		struct dirent* s_folder;
    		
    		//boucle pour lire le dossier
    		i = 0;
    		while((s_folder = readdir(folder)) != NULL)
    		{	
    			//On ne compte pas les fichier chaché
    			if(s_folder->d_name[0] != '.')
    			{
    				//On réaloue la case du tableau pour contenir la taille du nom du dossier + celui du fichier
    				tab[i] = str_realoc(tab[i], size_name_folder + size_str(s_folder->d_name));
    
    				tab[i] = concact_str(name_folder, s_folder->d_name);
    				i ++;
    			}
    		}
    
    	}
    	else
    		fprintf(stderr, "Imposible d'ouvrir le fichier %s\n", name_folder);
    
    
    	closedir(folder);
    
    	//On trie le tableau dans l'ordre alphabétique
    	str_alphabetical_order(tab, size_tab);
    
    	return tab;
    }
    
    void destroy_fillarray_with_name(char* name_folder, char** tab)
    {
    	int size_tab = nb_file_in_folder(name_folder);
    
    	//libération des cases du tableau
    	destroy_fillarray(tab, size_tab);
    
    }
    
    void destroy_fillarray(char** tab, int size_tab)
    {
    	for(int i = 0; i < size_tab; i ++)
    		free(tab[i]);
    	free(tab);
    }
    
    //trie un tableau dans l'ordre alphabétique
    static int string_compar(const void* str1, const void* str2)
    {
    	return strcmp(* (char* const*) str1, * (char* const*) str2);
    }
    
    void str_alphabetical_order(char** tab, int size_tab)
    {
    	qsort(tab, size_tab, sizeof(char*), string_compar);
    }
    
    
    

    filarray.h

    #ifndef FILLARRAY_H
    #define FILLARRAY_H
    
    //Retourne le nombre de fichier dans un dossier
    int nb_file_in_folder(char* name_folder);
    
    //Retourne le nom de fichier le plus grand
    int max_size_file_in_folder(char* name_folder);
    
    //Création d'un tableau de nom de fichier (NE PAS OUBLIER LE '/'  A LA FIN DU NOM DU FICHIER)
    char** tab_file_name(char* name_folder);
    //Libere le tableau de char** allouer
    void destroy_fillarray_with_name(char* name_folder, char** tab);
    void destroy_fillarray(char** tab, int size_tab);
    
    //Trie dans l'ordre alphabétique un tableau de chaine de caractère
    static int string_compar(const void* p1, const void* str2);
    void str_alphabetical_order(char** tab, int size_tab);
    
    
    #endif
    

    animation.c

    #include <stdio.h>
    #include <stdlib.h>
    
    #include "animation.h"
    #include "tools_sdl.h"
    #include "filarray.h"
    #include "chararray.h"
    
    
    //create texture array for animation
    SDL_Texture** create_tab_texture(SDL_Renderer* renderer, char* name_folder)
    {
    	//créatiion d'un tableau du nom des image
    	char** tab_name = tab_file_name(name_folder);
    	int size_tab = nb_file_in_folder(name_folder);
    	
    
    	//Initialisation du tableau de texture
    	SDL_Texture** tab_texture = malloc(sizeof(SDL_Texture*) * size_tab);
    	for(int i = 0; i < size_tab; i++)
    		tab_texture[i] = create_texture(renderer, tab_name[i]);	
    
    	//Destruction du tableau de nom d'image
    	destroy_fillarray(tab_name, size_tab);
    
    	return tab_texture;	
    }
    
    //animation loupe
    void animation_loop(SDL_Renderer* renderer, SDL_Texture** tab_animation, int size_tab, SDL_Rect* pos)
    {
    	for(int i = 0; i < size_tab; i++)
    	{
    		SDL_RenderClear(renderer);
    		SDL_RenderCopy(renderer, tab_animation[i], NULL, pos);
    		SDL_RenderPresent(renderer);
    	}
    }
    

    animation.h

    #ifndef ANIMATION_H
    #define ANIMATION_H
    
    #include <SDL.h>
    
    SDL_Texture** create_tab_texture(SDL_Renderer* renderer, char* name_folder);
    
    void animation_loop(SDL_Renderer* renderer, SDL_Texture** tab_animation, int size_tab, SDL_Rect* pos);
    #endif
    

    player.c

    #include <stdio.h>
    #include <stdlib.h>
    
    #include "player.h"
    #include "constante.h"
    #include "animation.h" 
    #include "filarray.h"
    
    
    //Constructeur
    Player* player_create(SDL_Renderer* renderer)
    {
    	Player* player = malloc(sizeof(Player));
    
    	//add renderer
    	player->p_renderer = renderer;
    
    	//create animation tab
    	player->idle_anim = create_tab_texture(player->p_renderer, PLAYER_IMG_IDLE);
    	//player->run_anim = create_tab_texture(player->p_renderer, PLAYER_IMG_RUN);
    	//size tab
    	player->size_idle_anim = nb_file_in_folder(PLAYER_IMG_IDLE);
    	//player->size_run_anim = nb_file_in_folder(PLAYER_IMG_RUN);
           	//init anim
    	player->p_animm = player->idle_anim;	
    
    	//init starter pos
    	player->pos.x = PLAYER_START_POS_X;
    	player->pos.y = PLAYER_START_POS_Y;
    	player->pos.w = PLAYER_SIZE_W;
    	player->pos.h = PLAYER_SIZE_H;
    	
    	//Init bool display player
    	player->is_display = SDL_TRUE;
    
    	return player;
    }
    
    //Destructeur
    void player_destroy(Player* player)
    {
    	if(player == NULL)
    		return;
    
    	//Destruction des texture
    	for(int i =0; i < player->size_idle_anim; i++)
    		SDL_DestroyTexture(player->idle_anim[i]);
    	for(int i = 0; i < player->size_run_anim; i++)
    		SDL_DestroyTexture(player->run_anim[i]);
    
    	//Liberation de la structure
    	free(player);
    }
    
    //Display
    int player_display(void* ptr)
    {
    	Player* player = ptr;
    
    	while(player->is_display)
    		animation_loop(player->p_renderer, player->idle_anim, player->size_idle_anim, &player->pos);
    
    	return EXIT_SUCCESS;
    }	
    

    player.h

    #ifndef PLAYER_H
    #define PLAYER_H
    
    #include <SDL.h>
    
    typedef struct{
    	//Animation
    	SDL_Texture** p_animm;
    	SDL_Texture** idle_anim;
    	int size_idle_anim;
    	SDL_Texture** run_anim;
    	int size_run_anim;
    
    	SDL_Rect pos;
    	SDL_Renderer* p_renderer;
    	SDL_bool is_display;
    
    }Player;
    
    //Construceur
    Player* player_create(SDL_Renderer* renderer);
    //Destructeur
    void player_destroy(Player* player);
    
    //Display
    int player_display(void* ptr);
    
    #endif
    

    constante.h

    #ifndef CONSTANTE_H
    #define CONSTANTE_H
    
    //Window
    #define SIZE_WINDOW_W 800
    #define SIZE_WINDOW_H 600
    
    //Player
    #define PLAYER_START_POS_X 100
    #define PLAYER_START_POS_Y 200
    #define PLAYER_SIZE_W 34
    #define PLAYER_SIZE_H 64
    	//animation
    #define DELAY_IDLE_PLAYER_ANIM 100
    #define DELAY_RUN_PLAYER_ANIM 100
    #define PLAYER_IMG_IDLE "img/player/idle/"
    #define PLAYER_IMG_RUN "img/player/run/"
    enum{
    	UP = 0, DOWN = 1, LEFT = 2, RIGHT = 3
    };
    
    
    #endif
    

    main.c

    #include <stdio.h>
    #include <stdlib.h>
    #include <SDL.h>
    #include <SDL_image.h>
    
    #include "constante.h"
    #include "tools_sdl.h"
    #include "player.h"
    #include "animation.h"
    
    
    int main(void)
    {
    	SDL_Window* window = NULL;
    	SDL_Renderer* renderer = NULL;
    	input_keys in;
    
    	SDL_Init(SDL_INIT_VIDEO);
    	input_key_init(&in);
    
    	if(SDL_CreateWindowAndRenderer(SIZE_WINDOW_W, SIZE_WINDOW_H,0, &window, &renderer) != 0)
    		fprintf(stderr, "Impossible de creer la fenetre et le rendu\n");
    
    	//Player create
    	Player* player = player_create(renderer);
    	//Init thread animation
    	SDL_Thread* t_anim;
    	t_anim = SDL_CreateThread(player_display, "display_anim_player", player);	
    
    	while(in.window_is_open)
    	{
    		update_event(&in);
    
    	//	SDL_RenderClear(renderer);
    		
    	//	SDL_RenderPresent(renderer);
    	}
    
    	if(in.window_is_open == SDL_FALSE)
    		player->is_display = SDL_FALSE;
    
    	//destruction struct 
    	player_destroy(player);
    
    	SDL_DestroyRenderer(renderer);
    	SDL_DestroyWindow(window);
    
    	return EXIT_SUCCESS;
    }
    










    • Partager sur Facebook
    • Partager sur Twitter
      3 avril 2022 à 12:38:14

      Je dois donc supposer que la dite fonction c'est tab_file_name ?

      Je n'ai pas regardé en détail mais ligne 98 tu semble faire une réallocation de mémoire affecté au pointeur tab[i] et ligne 100 tu lui affecte une autre valeur, tu perds donc l'adresse de ton allocation.

      • Partager sur Facebook
      • Partager sur Twitter
        3 avril 2022 à 12:54:09

        Il y a vraiment beaucoup de choses à dire sur ce code.

        Ce que tu fais a l'air quand même particulièrement compliqué, on dirait que tu souhaites charger un ensemble de SDL_Texture depuis un répertoire de manière dynamique. La solution peut paraitre future-proof mais en réalité c'est de la complexité pour rien : tôt où tard dans ton application tu devras associer un nom à une texture. Ce que je veux dire, c'est que cela signifie que tu sais quelle texture utiliser à quel moment et tu peux donc te contenter d'un tableau statique. Exemple :

        struct {
            const char *filename;
            SDL_Texture *texture;
        } all_textures[] = {
            { "mario.png" },
            { "luigi.png" },
            { NULL }
        };
        
        // On charge toutes les textures...
        for (size_t i = 0; all_textures[i].filename; ++i)
            all_textures[i].texture = load_texture_from_file(all_textures[i].filename);

        Parcourir un répertoire deux fois introduit forcément une situation de compétition. Entre le moment où tu l'as lu pour faire un prétraitement et que tu le reparcours il peut y avoir des changements. Bien sûr c'est rare, mais ça fait parti des mauvases pratiques.

        Utiliser l'API POSIX dirent.h c'est bien mais attention à la portabilité, windows ne le supporte pas.

        Essaye de coder entièrement en anglais (messages et commentaires).

        Avec SDL le rendu doit être fait dans le thread principal uniquement. Tu ne dois pas utiliser des fonctions de dessins autre part que dans le thread principal.

        • Partager sur Facebook
        • Partager sur Twitter

        l'azerty est aux dispositions ce que subversion est aux SCM

          3 avril 2022 à 13:12:13

          Donc si j'ai bien compris vaut mieux que j'initialise a la main mes tableaux de texture plutôt que d'essayer de l'automatiser.

          • Partager sur Facebook
          • Partager sur Twitter
            3 avril 2022 à 20:35:38

            Il y a un adage clé en informatique 🙂

            ”Less is more”

            • Partager sur Facebook
            • Partager sur Twitter

            l'azerty est aux dispositions ce que subversion est aux SCM

            ajout de carctere ?????

            × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
            • Editeur
            • Markdown