Discussion :

[chicabonux]

Je dois réaliser un programme qui testera si une phrase est un palindrome ou non en utilisant la méthode suivante :

Ecrire le programme réalisant:
-L'entrée des caractères un par un
-si le caractère est une majuscule,il est transformé en minuscule et mis dans un tableau t
-si le caractère est une minuscule,il est mis directement dans t
-s'il s'agit d'un autre type de caractère il est ignoré et on lit le caractère suivant
-la comparaison caractère à caractère du tableau
-si la comparaison est effectuée jusqu'au centre du tableau sans encombre,alors on affiche à l'écran le message"c'est un palindrome",sinon on écrit"ce n'est pas un palindrome"

voila le programme que j'ai réalisé :

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
#include<stdio.h>
 
int main()
{
	char t[100],courant=0;
    int i=0,j=0,longueur=0;
 
	printf("Tapez un cara : ");
	scanf("%c",&courant);
 
 
 
	for(courant;EOF!=courant;courant=getchar())
		putchar(tolower(courant),t[courant]);
 
		if(isalnum(t[courant]))t[courant]=getchar();
else courant++;
 
	longueur=strlen(t[courant]);
 
 
	for(i=0,j=longueur;i>j;i++,j--){
	if(i==j)
	printf("palin");
 
 
else printf("pas palin");
 
	} 
	return 0;
 
}

Ce programme s'arrête à la première boucle et je ne comprends pas pourquoi ?
Il ne semble même pas effectué le test sur le caractère alphanumérique ?

[gl]

Ce code ne compile pas:

||=== test_DVP, Release ===|
E:\projet\test_DVP\main.c|4|warning: function declaration isn't a prototype|
E:\projet\test_DVP\main.c||In function `main'
E:\projet\test_DVP\main.c|14|warning: implicit declaration of function `tolower'|
E:\projet\test_DVP\main.c|14|warning: array subscript has type `char'|
E:\projet\test_DVP\main.c|14|error: too many arguments to function `putchar'|
E:\projet\test_DVP\main.c|16|warning: implicit declaration of function `isalnum'|
E:\projet\test_DVP\main.c|16|warning: array subscript has type `char'|
E:\projet\test_DVP\main.c|16|warning: array subscript has type `char'|
E:\projet\test_DVP\main.c|19|warning: implicit declaration of function `strlen'|
E:\projet\test_DVP\main.c|19|warning: array subscript has type `char'|
E:\projet\test_DVP\main.c|19|error: passing arg 1 of `strlen' makes pointer from integer without a cast|
E:\projet\test_DVP\main.c|13|warning: statement with no effect|
||=== Build finished: 2 errors, 9 warnings ===|

En outre, je ne vois vraiment pas ce que tu cherches a faire avec

• Une variable courant qui sert à la fois à lire une entrée clavier et d'index de tableau.
• Du code en dehors de la boucle qui semble être destiné à se trouver à l'intérieur.
• Un comparaison d'indice pour déterminer si des caractères sont égaux (i==j)

Pourrais-tu poster du code compilable, indiquer dans le code ce que tu cherches à faire (commentaire) et réfléchir un minimum avant de taper n'importe qel bout de code.

[chicabonux]

Ok je vais réesssayer d'être logique mais je peine beaucoup

Voilà un code (qui fonctionne) qui calcule le nombre de caractères dans une chaine . Je sais que je suis mauvais et que j'éprouve beaucoup de difficultés dans mon apprentiqssage du langage . Je n'arrive pas à faire le test pour savoir si un caractère est alphanumérique ou non .

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
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 
int main(int argc, char *argv[])
{
    char chaine[100];
  	    long nombreDeCaracteres = 0;
    char caractereActuel = 0;
 
	printf("Veuillez ecrire une chaine de caracteres :");
		scanf("%s",chaine);
 
 
    do
    {
 
        caractereActuel = chaine[nombreDeCaracteres];
        nombreDeCaracteres++;
 
 
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0
 
    nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0
 
}
 
 
    printf("La chaine %s fait %ld caracteres de long\n", chaine, nombreDeCaracteres);
 
    return 0;
}

J'ai essayé de faire de cette manière mais bien entendu ça ne fonctionne pas

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
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 
int main(int argc, char *argv[])
{
    char chaine[100];
  	    long nombreDeCaracteres = 0;
    char caractereActuel = 0;
 
	printf("Veuillez ecrire une chaine de caracteres :");
		scanf("%s",chaine);
 
 
    do
    {
	if(isalnum(caractereActuel)){	
        caractereActuel = chaine[nombreDeCaracteres];
        nombreDeCaracteres++;
	}	
 
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0
 
    nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0
 
 
 
 
    printf("La chaine %s fait %ld caracteres de long\n", chaine, nombreDeCaracteres);
 
    return 0;
}

[Emmanuel Delahaye]

Ok je vais réesssayer d'être logique mais je peine beaucoup

Voilà un code (qui fonctionne) qui calcule le nombre de caractères dans une chaine .

Tu devrais commencer par compter tes {} ... une bonne mise en forme permet tout de suite de voir les problèmes ...

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
 
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 
int main (void)
{
   char chaine[100];
   long nombreDeCaracteres = 0;
   char caractereActuel = 0;
 
   printf ("Veuillez ecrire une chaine de caracteres :");
   scanf ("%s", chaine);
 
   do
   {
 
      caractereActuel = chaine[nombreDeCaracteres];
      nombreDeCaracteres++;
 
   }
/* On boucle tant qu'on n'est pas arrivé à l'\0 */
   while (caractereActuel != '\0');
 
/* On retire 1 caractère de long pour ne pas compter l'\0 */
   nombreDeCaracteres--;
 
}
 
printf ("La chaine %s fait %ld caracteres de long\n", chaine,
        nombreDeCaracteres);
 
return 0;
}

Je n'arrive pas à faire le test pour savoir si un caractère est alphanumérique ou non .

J'ai essayé de faire de cette manière mais bien entendu ça ne fonctionne pas

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
		scanf("%s",chaine);
 
 
    do
    {
	if(isalnum(caractereActuel)){	
        caractereActuel = chaine[nombreDeCaracteres];
        nombreDeCaracteres++;
	}	
 
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0

Le but est de compter les caractères alphanumériques ? En toute logique, dans la boucle, il faut
1 - lire le caractère dans le tableau :

Code :

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

        caractereActuel = chaine[nombreDeCaracteres];

2 - puis, si il est alphanumérique

Code :

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

	if(isalnum(caractereActuel)){

3 - incrémenter le compteur :

Code :

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

        nombreDeCaracteres++;

Ca ne te parait pas plus logique ?

[gl]

Le but est de compter les caractères alphanumériques ? En toute logique, dans la boucle, il faut
1 - lire le caractère dans le tableau :

Code :

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

        caractereActuel = chaine[nombreDeCaracteres];

2 - puis, si il est alphanumérique

Code :

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

	if(isalnum(caractereActuel)){

3 - incrémenter le compteur :

Code :

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

        nombreDeCaracteres++;

Ca ne te parait pas plus logique ?

Je rajouterais qu'il faut gérer en plus du compteur nombreDeCaracteres, un index pour parcourir la chaîne. Cet index sera utilisé à la place de nombreDeCaracteres pour récupérer le caractère courant et devra être incrémenté systématiquement dans la boucle.

[Emmanuel Delahaye]

Je rajouterais qu'il faut gérer en plus du compteur nombreDeCaracteres, un index pour parcourir la chaîne. Cet index sera utilisé à la place de nombreDeCaracteres pour récupérer le caractère courant et devra être incrémenté systématiquement dans la boucle.

Exact, il faut séparer le compteur de l'index de lecture.

[chicabonux]

C'est ce problème que je n'arrive pas à comprendre en fait . Je me mélange dans les index des tableaux et je ne sais plus quelles variables utilisées ?

[chicabonux]

Nouvel essai mais je n'arrive toujours pas à tester la chaine pour savoir si ce sont des caractères alphanumériques

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
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 
int main(int argc, char *argv[])
{
    char chaine[100];
  	    long nombreDeCaracteres = 0,i=0,longueur=0;
    char caractereActuel = 0;
 
	printf("Veuillez ecrire une chaine de caracteres :");
		scanf("%s",chaine);
 
 /*On calcule la longueur de la chaine*/
	longueur=strlen(chaine);
 
	/*La boucle permettant d'initialiser la chaine et de voir si ce sont des caractères alphanumériques*/
    do
    {
		caractereActuel=chaine[nombreDeCaracteres];
        for(i=0;i<=longueur;i++)
			if(isalnum(caractereActuel))caractereActuel=chaine[nombreDeCaracteres];
        nombreDeCaracteres++;
 
 
 
 
    }
    while(caractereActuel != '\0'); // On boucle tant qu'on n'est pas arrivé à l'\0
 
 
 
nombreDeCaracteres--; // On retire 1 caractère de long pour ne pas compter l'\0
 
 
    printf("La chaine %s fait %ld caracteres de long\n", chaine, nombreDeCaracteres);
 
    return 0;
}

En fait je ne comprends pas pourquoi le programme ne prend pas en compte le test pour les caractères alphanumériques ?

[koala01]

Salut,

Déjà, tu ne respecte pas les indications fournies par l'énoncé: tu utilise scanf (qu'il est généralement peut recommandé d'utiliser au passage) pour l'introduction du mot à tester, or, ton énoncé indique clairement que tu dois utiliser une introduction "caractère par caractère"...

Ensuite, l'idéal reste toujours de veiller à ce qu'une fonction ne fasse qu'une chose mais qu'elle le fasse bien.

Il serait donc opportun de penser à séparer les différentes actions en fonction particulières.

Par exemple, tu pourrais avoir les fonctions:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/* @function int introClavier(char* tab)
 * Fonction s'occupant de l'introduction clavier
 * @ in : le pointeur sur le premier élément du tableau de caractères dans 
 *        lequel l'introduction clavier sera placée
 * @ out : le nombre de caractères introduits par l'utilisateur
 */
int introClavier(char * tab);
/* @function void testPalindrome(char* tab, int size)
 * Fonction s'occupant de tester si le mot introduit est un palindrome
 * @ in : le pointeur sur le premier élément de la chaine de caractères
 *      : la taille de la chaine de caractères ('/0) compris
 * @ out : néans
 */
void testPalindrome(char* tab, int size);

Enfin, il est généralement déconseillé d'utiliser des valeurs "magiques" (des valeurs qui ne sortent de nulle part), surtout pour ce qui est destiné à représenter des tailles maximales...

Il serait pas mal de prévoir une constante globale nommée, par exemple MaxSize, représentant la... taille maximale admise pour la chaine...

Au final, la structure de base de ton fichier main.c deviendrait proche de

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
const int MaxSize = 100; /* la taille maximale admise pour la chaine */
/* déclaration des fonctions utiles */
 int introClavier(char* tab);
void testPalindrome(char* tab, int size);
 
int main(void)
{
    char chaine[MaxSize]; /* la chaine de caractères */
    int size = 0;/* la taille de la chaine de caractères */
    size = introClavier(chaine);
    testPalindrome(chaine, size);
    return 0;
}
int introClavier(char* tab)
{
    /* je suis sympa, je te donne le début */
    char c; /* le caractère introduit par l'utilisateur */
    int size = 0; /* au départ, la taille est de 0 */
    int encore = 1; /*on passe à 0 quand il faut quitter la boucle ;) */
    while(size<MaxSize && encore)/*Tant qu'on peut introduire un caractère */
    {
        /* Je te laisse réfléchir à ce qu'il faut faire, mais il ne faut pas
         * oublier, en fin de boucle le:
         */
        ++size;
    }
    return size;
}
void testPalindrome(char* tab, int size)
{
    /*ici aussi, je te mets sur la voix ;) */
    int reelle = size-1; /* il ne faut pas prendre le '\0' en compte */
    int centre = reelle/2; /* il est utile de savoir la position de la lettre
                            * centrale
                            */
    int palindrome = 1; /* pour savoir si c'est un palindrome ou non */
    int compteur = 0; /* le compteur pour savoir quel caractère tester */
    /* la boucle qui va tout tester */
    while(compteur<=centre && palindrome)
    {
        /* je te laisse réfléchir à ce qu'il faut faire, mais il faudra
         * penser à passer palindrome à 0 s'il apparait que ce n'en est
         * pas un...
         * ne pas oublier, en fin de boucle le:
         */
        ++compteur;
    }
    /* l'affichage du résultat */
    if(palindrome)
    {
    }
    else
    {
    }
}

[chicabonux]

Merci de ton aide mais j'ai l'impression que ta solution est un peu trop sophistiquée pour mon niveau . Je ne suis que débutant et on me déconseille dans mes cours d'utiliser des variables globales ainsi que de donner une variable comme taille de tableau .

Je cherche donc à réaliser des fonctions qui me permettront d'arriver au résultat d'une manière plus simple .

Mais je te remercie encore et j'arrive à comprendre ton code . Je pourrais essayer plus tard de réaliser les différentes fonctions que tu me proposes .

Par contre comment ça se fait que mon programme cité au dessus ne fonctionne pas ? Je demande trop de résultats à la même fonction ?

[koala01]

Je ne vois pas en quoi cette solution est "trop compliquée"...

les deux fonctions que j'ai présentées sont celles qu'il te faut de manière à pouvoir déléguer correctement les responsabilités

J'ai peut être rajouté quelques variables qui pourraient être remplacées par un calcul, mais je préfères éviter de refaire des calculs qui peuvent devenir inutile simplement en déclarant une variable qui peut en représenter le résultat

D'un autre coté, on a raison de te déconseiller de "jouer" avec des variables globales, mais il faut prendre ce conseil, comme la plupart des conseils que l'on peut donner, avec une certaine latitude...

A titre personnel, je préfères utiliser une constante globale déclarées sous la forme de

Code :

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

 const int Variable = valeur;

plutôt qu'une directive préprocesseur proche de

Code :

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

#define VARIABLE valeur

[EDIT] En outre, il y a une différence de taille entre une variable globale et une constante globale: la première risque d'être modifiée n'importe où...

Ce n'est pas le cas d'une constante, et c'est ce qui justifie qu'une variable globale soit mal, mais qu'une constante globale puisse prendre tout son sens

[gl]

A titre personnel, je préfères utiliser une constante globale déclarées sous la forme de

Code :

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

 const int Variable = valeur;

plutôt qu'une directive préprocesseur proche de

Code :

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

#define VARIABLE valeur

Si ce n'est qu'en C,

Code :

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

 const int Variable = valeur;

n'est pas une véritable "constante" mais une "variable en lecture seule". Et donc la construction char chaine[MaxSize]; n'est pas un simple tableau statique mais un VLA, notion introduite uniquement dans C99 et pas supportée correctement par tout les compilateurs.

[chicabonux]

Justement c'est le problème du tableau avec une variable pour désigner la taille . Je suis le tuto du SDZ pour le langage en même temps que mes cours Educatel
et dans le tuto il est dit :

Les tableaux à taille dynamique


Le langage C existe en plusieurs versions.
Une version récente, appelée le C99, autorise la création de tableaux à taille dynamique, c'est-à-dire de tableaux dont la taille est définie par une variable :

Code : C

1
2



long taille = 5;
long tableau[taille];



Or, cela n'est pas forcément reconnu par tous les compilateurs, certains planteront sur la ligne n°2.
Le langage C que je vous enseigne depuis le début (appelé le C89) n'autorise pas ce genre de choses. Nous considèrerons donc que faire cela est interdit.

Nous allons nous mettre d'accord sur la chose suivante : vous n'avez pas le droit de mettre une variable entre crochets pour la définition de la taille du tableau, même si cette variable est une constante ! const long taille = 5; ne marchera donc pas mieux.
Le tableau doit avoir une dimension fixe, c'est-à-dire que vous devez écrire noir sur blanc le nombre correspondant à la taille :

Code : C

1



long tableau[5];

Voilà pourquoi je cherche une autre solution à mon problème

J'ai une autre question . Qu'est ce qu'un VLA ?

[koala01]

Si ce n'est qu'en C,

Code :

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

 const int Variable = valeur;

n'est pas une véritable "constante" mais une "variable en lecture seule". Et donc la construction char chaine[MaxSize]; n'est pas un simple tableau statique mais un VLA, notion introduite uniquement dans C99 et pas supportée correctement par tout les compilateurs.

Au temps pour moi...

A decharge, je manipule beaucoup plus C++, et Gcc supporte cette écriture.

Ceci dit, cette norme a quand même... 10 ans, si elle date bien de 1999 comme le laisse à penser le nombre qui suit

Dés lors, on peut se poser la question de savoir quels compilateur C *récents* ne supportent pas encore la norme à ce point de vue... pour les éviter comme la peste

Mais, si une majorité des compilateurs *récents* ne supportent pas cette possibilité, restons en alors au bon vieux define, histoire de malgré tout éviter le valeurs magiques

J'ai une autre question . Qu'est ce qu'un VLA ?

Ca doit sans doute etre l'acronyme de Variable Length Array

Ceci dit, il semble que ta logique laisse fortement à désirer au niveau de ta boucle do - while, que je remet correctement en forme poru l'occasion:

Code :

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

1
2
3
4
5
6
7
8
9
10
do
{
    caractereActuel=chaine[nombreDeCaracteres];
    for(i=0;i<=longueur;i++)
    {
        if(isalnum(caractereActuel))
            caractereActuel=chaine[nombreDeCaracteres];
    }
    nombreDeCaracteres++;
}while(caractereActuel != '\0');

Pour l'exemple, essayons de "dérouler" mentalement le comportement de ces boucles avec la chaine "salut\0"
Au départ, nous avons donc les valeurs:

• nombreDeCaracteres = 0;
• longueur = 6
• chaine = "salut\0"

• Debut boucle do While
• caractereActuel := 's'
• debut boucle "pour"
  
  • Avec i = 0
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 1
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 2
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 3
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 4
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 5
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s' (==chaine[0])
  • avec i = 6
  • isalnum('s') renvoie vrai donc
    • caractereActuel :='s'(==chaine[0])
• fin boucle pour
• NombreCaracteres := 1 (0+1)
• caractereActuel := 'a'
• refaire la boucle à l'identique, mais avec caractereActuel = 'a'
• fin boucle pour
• NombreCaracteres := 2 (1+1)
• Va continuer dans la même veine avec 'l','u' et 't'
• Avec le caractère '\0', le test isalnum('\0) donne faux, et l'assignation caractereActuel = chaine[nombreDeCaracteres] n'est donc pas effectuée (mais caractereActuel ne change toujours pas)
• fin boucle do while

bref, tu va parcourir la boucle NombreCaracteres fois longueur (soit 6*6 = 36 ) fois pour... strictement rien ... Et tu ne respecte de toutes manières pas l'énoncé de départ

[souviron34]

Ceci dit, cette norme a quand même... 10 ans, si elle date bien de 1999 comme le laisse à penser le nombre qui suit

Dés lors, on peut se poser la question de savoir quels compilateur C *récents* ne supportent pas encore la norme à ce point de vue... pour les éviter comme la peste

D'une part pour son saut "discontinu" sur certaines choses, d'autre part parce qu'il reste quelques points de désaccord dans les "nouveautés"..

Et 10 ans est le cycle normal.

Les normes Fortran, par exemple, ont 20 ans d'avance. Quand une norme sort, elle prévoit que dans 10 ans telle fonction deviendra "obsolète", ce qui veut dire qu'à la révision suivante (20 ans plus tard), elle aura disparu, et elle liste une série de fonctions qui sont maintenant "obsolètes" (qui donc disparaitront dans 10 ans), ce qui laisse entre 10 et 20 ans de compatibilité, et donc de temps pour ré-écrire.

C'est un peu le problème avec C99. Les changements n'ont pas été annoncés à l'avance, et ne sont pas toujours compatibles. (comme les // au lieu des /* ou les déclarations de variables après des instructions).

Du coup, la "norme" est restée C90-95, avec une possibilité C99. Maintenant nous arrivons à 10 ans, ce qui tendrait à être un début de mise en application globale.

Mais... C'est encore à voir.. vu la quantité de code restant conforme aux anciennes versions, et le saut discontinu représenté..

[Emmanuel Delahaye]

Du coup, la "norme" est restée C90-95, avec une possibilité C99. Maintenant nous arrivons à 10 ans, ce qui tendrait à être un début de mise en application globale.

AMA, tant que Microsoft refusera le C99, rien de bougera vraiment...

[koala01]

Je comprend le point de vue de manière générale, mais, pour le cas particulier qui nous intéresse (l'utilisation d'une constante globale comme taille de tableaux), je serais énormément surpris si tu venais à me dire que la norme C99 a décidé de supprimer la directive préprocesseur #define...

Partant de là, les code conformes aux anciennes versions resteraient tout à fait conformes, tant il est vrai que des

Code :

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

#define SIZEMAX 100

sont monnaie courante

Ici, et bien que je ne connaisse pas moitié aussi bien la norme du C que celle du C++, le changement se "contente" de rajouter une possibilité, sans invalider ce qui existe par ailleurs depuis "toujours"

AMA, tant que Microsoft refusera le C99, rien de bougera vraiment...

Evidemment... on en revient toujours au problème Microsoft dés qu'on parle de norme...

Mais pourquoi diable les a-t-on laissé en arriver à une situation de quasi monopole de fait en informatique "personnelle"

[souviron34]

Ici, et bien que je ne connaisse pas moitié aussi bien la norme du C que celle du C++, le changement se "contente" de rajouter une possibilité, sans invalider ce qui existe par ailleurs depuis "toujours"

lol non je parlais à propos des VLA.



PS: d'ailleurs, ce "retard" ou "non-acceptation" de la norme indique quelque chose de plus général, qui malheureusement est trop négligé ou méconnu en informatique.. Une "norme" n'est réellement une norme que quand elle est mise en application. Or il peut exister des cas où une construction intellectuelle ne corresponde pas à la réalité, ou comporte des biais, ou des inconvénients. Ces dernières années on a vu apparaître beaucoup de "choses" normatives, dans les concepts, conceptions, outils, méthodologies, et autres, dont j'attend avec impatience le jugement de l'Histoire

Mais pourquoi diable les a-t-on laissé en arriver à une situation de quasi monopole de fait en informatique "personnelle"

Tu viens de donner la réponse toi-même...

Les seuls ordis destinés aux particuliers furent les Mac et les PC..

Il se trouve que les Mac (c'était particulièrement visible en France dans les années 80) furent utilisés en majorité dans les universités, les commerciaux de M se focalisant sur Mr Tout le Monde...


MAis au delà de ça, c'est vraiment qu'il n'y en a eu que 2 : Mac et PC. Et que les Mac étaient pour les "utilisateurs" (programmes tous faits), les PC pour les "utilisateurs", mais aussi pour les "programmeurs" (DOS, puis Pascal).

[gl]

Evidemment... on en revient toujours au problème Microsoft dés qu'on parle de norme...

Mais pourquoi diable les a-t-on laissé en arriver à une situation de quasi monopole de fait en informatique "personnelle"

Effectivement, Microsoft ne souhaite pas implémenter C99.
Mais concernant le support des VLA, c'était toujours broken dans gcc la dernière que j'ai regardé (il faudrait que je regarde les dernières versions), la syntaxe que tu donnes est bien supporté par gcc depuis assez longtemps mais pas exactement de la manière décrite par la norme.

Ce qui fait au moins deux compilateurs très répandus qui ne supporte pas correctement les VLA.
En outre, je ne vois pas vraiment l'intérêt et les avantages apportés par les VLA, donc ça ne me choque pas de ne pas les utiliser.

Par contre pour en revenir à ta proposition initiale, je trouve regrettable que const de définisse pas de vrai constantes utilisables comme telles.

[chicabonux]

Je n'arrive pas à utiliser la fonction isalnum

J'aimerais afficher que les caractères alphanumériques et ce code m'affiche autre chose . Je ne comprends pas pourquoi .

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
#include<stdio.h>
#include<ctype.h>
#include<string.h>
 
main()
{
	char chaine[100];
	char courant=0;
 
	printf("tapez un caractere : ");
	courant=getchar();
 
 
		for(courant;EOF!=courant;courant=getchar())
			putchar(isalnum(courant),chaine[courant]);
 
 
	return 0;
}