Discussion :

[herve.02]

Bonjour,

J'aimerais pouvoir faire fonctionner ce convertisseur Gold/Root , et comprendre sa programmation car je n'arrive pas à le faire fonctionner avec Code::Blocks 20.03
J'obtiens l'affichage suivant: "Specify either root or gold code with -r or -g"
Normalement, dans tout convertisseur, il faut entrer une valeur, par exemple une valeur Gold qui est donc ensuite convertie en Root (ou inversement Root vers Gold)
Je ne comprend pas pourquoi cela me demande de spécifier -r ou -g , et surtout je ne sais pas où taper cette valeur car une fois le programme lancé il n'y a pas de possibilité d'entrer une valeur, et si j'appuis sur une touche du clavier cela fait quitter la console.
Je suis novice en C++ , c'est probablement la cause, j'aimerai donc savoir si ce convertisseur fonctionne, et comprendre pourquoi cela ne fonctionne pas chez moi.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <stdint.h>
#include <stdlib.h>
#include <getopt.h>
#include <stdio.h>
#include <stdint.h>
 
static uint32_t gold2root(uint32_t gold)
{
	uint32_t x, g;
 
	for (g = 0, x = 1; g < gold; g++)
		x = (((x ^ (x >> 7)) & 1) << 17) | (x >> 1);
	return x;
}
 
static uint32_t root2gold(uint32_t root)
{
	uint32_t x, g;
 
	for (g = 0, x = 1; g < 0x3ffff; g++)  {
		if (root == x)
			return g;
		x = (((x ^ (x >> 7)) & 1) << 17) | (x >> 1);
	}
	return 0xffffffff;
}
 
int main(int argc, char **argv)
{
	uint32_t gold = 0xffffffff, root = 0xffffffff;
 
	while (1) {
                int option_index = 0;
		int c;
                static struct option long_options[] = {
			{"gold", required_argument, 0, 'g'},
			{"root", required_argument, 0, 'r'},
			{"help", no_argument , 0, 'h'},
			{0, 0, 0, 0}
		};
                c = getopt_long(argc, argv, 
				"r:g:h",
				long_options, &option_index);
		if (c==-1)
 			break;
 
		switch (c) {
		case 'g':
			gold = strtoul(optarg, NULL, 0);
			break;
		case 'r':
			root = strtoul(optarg, NULL, 0);
			break;
		case 'h':
			printf("pls -g gold_code\n");
			printf("or\n");
			printf("pls -r root_code\n");
			exit(-1);
		default:
			break;
 
		}
	}
	if (optind < argc) {
		printf("Warning: unused arguments\n");
	}
	if (gold != 0xffffffff && root != 0xffffffff) {
		printf("Only specify root or gold code\n");
		exit(-1);
	};
	if (gold != 0xffffffff) {
		if (gold < 0x3ffff) {
			root = gold2root(gold);
			printf("gold = %u (0x%05x)   root = %u (0x%05x)\n",
			       gold, gold, root, root);
		} else
			printf("Invalid gold code specified.\n");
		exit(0);
	} 
	if (root != 0xffffffff) {
		if (root > 0 && root < 0x40000)
			gold = root2gold(root);
		if (gold != 0xffffffff)
			printf("gold = %llu (0x%05x)   root = %llu (0x%05x)\n",
			       gold, gold, root, root);
		else
			printf("Invalid root code specified.\n");
		exit(0);
	}
	printf("Specify either root or gold code with -r or -g.\n");
}

Merci d'avance pour votre aide.

[Bktero]

La ligne 60 dans le code montre l'aide de la commande : tu passes une valeur en paramètre et tu précises avec l'option -g ou -r si c'est une valeur GOLD ou une valeur ROOT.

[AbsoluteLogic]

Bonjour,

Je ne sais pas quel est ton objectif, mais si c'est éducatif, il vaut mieux suivre un totoriel et avancer étape par étape (au passage, le code que tu as donné n'utilises pas du tout de C++, seulement du C).
Mais bon, il semble que tu ais un besoin précis avec ce convertisseur, donc je vais accélérer les choses :
* le -r ou -g te permet de spécifier si tu veux convertir de Gold en Root ou de Root en Gold
* Ce sont des "arguments de programme". Ils se spécifient par commande au lancement du programme, et non par "l'input" du programme (l'input est ce que tu tapes au clavier après le lancement du programme, comme ce que t'essayais de faire). Avec CodeBlocks (que je ne connais pas, mais Google fais l'affaire), il semble que ce soit avec le menu "Projet > Set programs' arguments"
* Dans le programme C/C++, ces valeurs sont stockées dans argv, paramètre du main. Ici, ce programme utilise la fonction getopt_long (ligne 47) pour aider à la lecture de ces valeurs, mais on peut généralement se passer de ça. (cf un tuto quelconque)

Voilà, si tu veux comprendre le reste du programme, il vaut mieux suivre des tutos en partant de zéro.

[herve.02]

Merci Bktero et AbsoluteLogic
Pour l'instant tout est en très grande partie incompréhensible, j'essaierai par la suite à l'aide de tuto de décortiquer toutes les étapes en commençant par apprendre les bases pour comprendre puis reproduire les lignes de commande.
Mais effectivement ce que je recherche pour l'instant c'est de pouvoir convertir un nombre décimal de Root vers Gold ou inversement grace à ce programme.
Je ne sais pas quoi utiliser pour faire fonctionner cela, et où entrer le nombre entier à convertir.
J'ai pris CodeBlocks au hasard, il y a peut être mieux (en tous cas plus adapté à ce que je veux faire : convertir un nombre)
Mais je suis preneur s'il existe un programme en langage C donnant la possibilité, avant de cliquer sur RUN, d'entrer une valeur (de façon simple, et permettant de spécifier -r ou -g pour dans mon cas le sens de conversion).

[herve.02]

Bien vu AbsoluteLogic,
la conversion fonctionne effectivement en écrivant dans Project/Set Program's arguments : -r (ou -g) suivi du nombre
je vais me coucher moins bête !
Reste plus qu'à parcourir les tutos de Developpez.com pour apprendre les bases du C et C++

[dybmans]

Ce code implémente un programme qui convertit des codes "gold" en codes "root" et vice versa.

Les librairies incluses sont :

<stdio.h> pour les entrées/sorties de données,
<ctype.h> pour les fonctions de traitement de caractères,
<string.h> pour les fonctions de traitement de chaînes de caractères,
<unistd.h> pour les fonctions liées à l'environnement Unix,
<sys/types.h> pour les définitions de types système,
<sys/stat.h> pour les structures et fonctions d'informations sur les fichiers,
<stdint.h> pour les types d'entiers standards avec une largeur de bits fixe,
<stdlib.h> pour les fonctions de base de la bibliothèque standard,
<getopt.h> pour les fonctions pour traiter les options de ligne de commande.
Il y a deux fonctions statiques :

gold2root : prend un code "gold" en entrée et renvoie le code "root" correspondant.
root2gold : prend un code "root" en entrée et renvoie le code "gold" correspondant.
La fonction main traite les options de la ligne de commande en utilisant la fonction getopt_long :

'-g' ou '--gold' pour spécifier un code "gold",
'-r' ou '--root' pour spécifier un code "root",
'-h' ou '--help' pour afficher un message d'aide.

Le code "gold" ou "root" est converti en utilisant la fonction correspondante (gold2root ou root2gold) et les résultats sont affichés.
Si aucun code n'est spécifié, le programme affiche un message d'erreur demandant de spécifier un code.