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

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.

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.

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.

Il y a un adage clé en informatique 🙂

”Less is more”