Bonjour,

Tout est dans le titre, j'ai reussi a construire une liste chaînée qui affiche les int que je lui donne en paramètres mais j'aimerais construire une liste chaînée qui affiche les arguments du main et je ne vois pas trop comment faire :/

Par exemple ./aout 20 40 60 80 affichera 20 40 60 80

Voici mon implémentation pour le moment :

# include <stdlib.h>
# include <stdio.h>

typedef struct s_list t_list;

struct s_list
{
	int		value;
	t_list	*next;
};

void	add_node_end(t_list **head, int value);
void	add_node_start(t_list **head, int value);
int		remove_first(t_list **head);
int		remove_last(t_list *head);
int		remove_by_index(t_list **head, int n);
void	print_list(t_list *head);

// Ajouter un noeud en fin de liste

void	add_node_end(t_list **head, int value)
{
	t_list	*current;
	current = *head;

	while (current->next != NULL)
		current = current->next;
	
	current->next = malloc(sizeof(t_list));
	current->next->value = value;
	current->next->next = NULL;
}

// Ajouter un noeud en debut de liste
// 1) Créer un nouveau noeud et le malloc
// 2) Le faire pointer sur la tête de liste
// 3) Definir la tete de liste comme notre nouveau noeud

void	add_node_start(t_list **head, int value)
{
	t_list	*new;
	new = malloc(sizeof(t_list));
	
	new->value = value;
	new->next = *head;
	*head = new;
}

// Supprimer le 1er element de la liste
// 1) Sauvegarder le noeud post *head
// 2) Free la tete
// 3) Definir la tete

int	remove_first(t_list **head)
{
	t_list	*next_node;
	int	retvalue;
	
	retvalue = -1;
	next_node = NULL;
	
	if (*head == NULL)
		return (-1);
	
	next_node = (*head)->next;
	retvalue = (*head)->value;
	free(*head);
	*head = next_node;

	return (retvalue);
}

// Supprimer le dernier element de la liste
// Semblable a l'ajout d'un element en fin de liste sauf qu'on va regarder 2 elements
// Avant le dernier et voir si l'element suivant est le dernier de la liste

int	remove_last(t_list *head)
{
	t_list	*current;
	int		retvalue;

	retvalue = 0;

	// S'il y a qu'un seul element dans notre liste, on le supprime

	if (head->next == NULL)
	{
		retvalue = head->value;
		free(head);
		return (retvalue);
	}

	// Sinon on va parcourir la liste depuis la tete
	// Et aller a l'avant-dernier element
	
	current = head;
	while (current->next->next != NULL)
		current = current->next;
	
	// Maintenant que *current pointe vers l'avant-dernier element de la liste
	// On va supprimer current->next

	retvalue = current->next->value;
	free(current->next);
	current->next = NULL;
	
	return(retvalue);
}

// Supprimer un element specifique
// 1) Iterer jusqu'au noeud avant celui qu'on veut supprimer
// 2) Enregistrer le noeud qu'on veut supprimer dans un pointeur temporaire
// 3) Set the previous node's next pointer to point to the node after the node we wish to delete
// 4) Supprimer le noeud a l'aide du pointeur temporaire 

int	remove_by_index(t_list **head, int n)
{
	t_list	*current;
	t_list	*temp_node;
	int	retvalue;
	int	i;
	
	i = 0;
	retvalue = -1;
	
	if (n == 0)
		return (remove_first(head));
	
	while (i < n - 1)
	{
		if (current->next == NULL)
			return (-1);
		current = current->next;
		i++;
	}
	temp_node = current->next;
	retvalue = temp_node->value;
	current->next = temp_node->next;
	free(temp_node);

	return(retvalue);
}

void	print_list(t_list *head)
{
	t_list	*current;
	current = head;
	
	while (current != NULL)
	{
		printf("%d\n", current->value);
		current = current->next;
	}
}

int main(void)
{
	t_list	*head;
	head = NULL;
	
	add_node_start(&head, 10);
	add_node_end(&head, 20);
	add_node_end(&head, 30);
	add_node_end(&head, 40);
	add_node_end(&head, 50);
	print_list(head);

	return (0);
}

Avez-vous une idee ? Merci

-
Edité par Ontimeyes 27 septembre 2022 à 10:02:10

Essais déjà d'afficher les arguments du main.

Tu vas les récupérer depuis les paramètres de la fonction main.

int main(int argc , char *argv[])
{
    puts(argv[0]);
}

argc étant le nombre d'argument et argv étant un pointeur sur des chaînes de caractère contenant les argument. 

Tu vas donc les récupérer sous forme de chaîne de caractère.

Tout en sachant que la premiere et le nom de l'exécutable avec son chemin.

Bonjour,

En lisant la doc ptêt ? → Program startup.

Pour TL;DR :

Il faut commencer par utiliser le bon prototype pour la fonction main :

int main(int argc, char *argv[]) {
    …
}

Ensuite, pour faire court : si argc est strictement plus grand que 0 tu auras les arguments passés au programme dans les chaînes argv[1] à argv[argc-1]. Ce sont des chaînes, donc si tu veux des entiers il va falloir les parser.

Infos complémentaires : argv[0] peut contenir le nom/l'exécutable avec ou sans chemin/rien suivant l'OS et la manière dont le programme a été lancé.

argv[argc] contient toujours NULL.

Edit: typo

-
Edité par White Crow 27 septembre 2022 à 10:27:38

// ...

int main(int argc, char *argv[])
{
  int value;
  t_list *head = NULL;

  if(argc <= 1) {
    fprintf(stderr, "Erreur : argument(s) manquant(s)\n");
    return EXIT_FAILURE;
  }

  if(sscanf(argv[1], "%d", &value) == 1){
    add_node_start(&head, value);
  }

  if(head){
    for(int i = 2; i < argc; i++){
      if(sscanf(argv[i], "%d", &value) == 1){
        add_node_end(&head, value);
      }
    }

    print_list(head);
  }

  return EXIT_SUCCESS;
}