Discussion :

[ugo188]

Bonjour à tous et à toutes,

Je m'étais dit que ca pourrait être intéressant de regrouper quelque part, l'ensemble des 'bizareries' du langage C.

Qu'est ce que j'entends par 'bizareries'?
Ce n'est pas le meilleur terme je le concoit, mais je n'en ai pas trouvé d'autre.
Il s'agirait plutôt de code difficile à interpréter, de choses qui ne semblent pas compiler, etc.

Comme un exemple vaut mieux qu'un long discours, voici des exemples:
-Le fait d'inverser l'index avec la variable du tableau : tab[1] équivaut à 1[tab]
-De déclarer des variables dans un switch mais ailleurs que dans un case, puis de l'afficher.

Donc si vous avez des idées ou bouts de code qui traine, c'est le moment!

Bonne soirée!

[Sve@r]

Salut

Ton idée n'est pas nouvelle. Il existe même un concours du programme C le plus illisible. Je crois qu'en tapant des mots clefs comme "worst" "programming" dans google tu peux trouver ça

Toutefois, c'est pas évident de qualifier ce qui est bizarre. Déjà pourquoi est-ce bizarre ? Parce que c'est peu usité (comme ton exemple tab[i] <=> i[tab] et, pour faire suivre, tab[i][j] <=> j[i[tab]]) ? C'est vrai que le terme est un peu inadéquat. Après-tout, si la syntaxe est acceptée alors elle n'a rien de bizarre.

Mais bon, je vais contribuer à ton effort. Regarde ce code

Code c :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>
int carre(int x)
{
     return x * x;
}
 
int main()
{
    void *ptF=carre;
 
    printf("Le carré de 2 est %d\n", (*ptF)(2));
    printf("Le carré de 3 est %d\n", (**ptF)(3));
    printf("Le carré de 4 est %d\n", (***ptF)(4));
    printf("Le carré de 5 est %d\n", (****ptF)(5));
}

Et tu peux rajouter autant d'étoiles que ça te chante. Ca c'est une sacré bizarrerie non ???

[jabbounet]

Salut

Ton idée n'est pas nouvelle. Il existe même un concours du programme C le plus illisible. Je crois qu'en tapant des mots clefs comme "worst" "programming" dans google tu peux trouver ça

tu veux parler de
http://www.ioccc.org/main.html

[ugo188]

Ton idée n'est pas nouvelle. Il existe même un concours du programme C le plus illisible.

Comme dit précédemment ce n'est pas forcément une question de lisibilité, juste de comportement jamais testé, et autres autorisations de la syntaxe C.

Je crois qu'en tapant des mots clefs comme "worst" "programming" dans google tu peux trouver ça

Merci, je jetterais un oeil, car mes recherches francaise n'avaient pas donné grand chose!

Après-tout, si la syntaxe est acceptée alors elle n'a rien de bizarre.

Nous sommes d'accord, après ce n'est qu'une question de connaissance. Tout comme l'ajout d'instructions dans le switch.

En revanche le code que tu as donné ne compile 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
 
moi::localhost> alias gcc
gcc='gcc -W -Wall -ansi -pedantic'
moi::localhost> gcc fptr2.c
fptr2.c: In function ‘main’:
fptr2.c:9: warning: ISO C forbids initialization between function pointer and ‘void *’
fptr2.c:11: warning: dereferencing ‘void *’ pointer
fptr2.c:11: error: called object ‘*ptF’ is not a function
fptr2.c:12: warning: dereferencing ‘void *’ pointer
fptr2.c:12: error: void value not ignored as it ought to be
fptr2.c:13: warning: dereferencing ‘void *’ pointer
fptr2.c:13: error: void value not ignored as it ought to be
fptr2.c:14: warning: dereferencing ‘void *’ pointer
fptr2.c:14: error: void value not ignored as it ought to be
moi::localhost>

En revanche celui-ci donne le comportement attendu:

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
 
#include <stdio.h>
 
int	carre(int x)
{
     return x * x;
}
 
int	main()
{
  int (*ptF)(int) = &carre;
 
  printf("Le carrM-CM-) de 2 est %d\n", (*ptF)(2));
  printf("Le carrM-CM-) de 3 est %d\n", (**ptF)(3));
  printf("Le carrM-CM-) de 4 est %d\n", (***ptF)(4));
  printf("Le carrM-CM-) de 5 est %d\n", (****ptF)(5));
  return (0);
}

Et en effet, c'est bizzare!
Merci de la contribution!

[uknow]

En revanche le code que tu as donné ne compile 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
 
moi::localhost> alias gcc
gcc='gcc -W -Wall -ansi -pedantic'
moi::localhost> gcc fptr2.c
fptr2.c: In function ‘main’:
fptr2.c:9: warning: ISO C forbids initialization between function pointer and ‘void *’
fptr2.c:11: warning: dereferencing ‘void *’ pointer
fptr2.c:11: error: called object ‘*ptF’ is not a function
fptr2.c:12: warning: dereferencing ‘void *’ pointer
fptr2.c:12: error: void value not ignored as it ought to be
fptr2.c:13: warning: dereferencing ‘void *’ pointer
fptr2.c:13: error: void value not ignored as it ought to be
fptr2.c:14: warning: dereferencing ‘void *’ pointer
fptr2.c:14: error: void value not ignored as it ought to be
moi::localhost>

Bonjour,

Effectivement, le C standard ne définit pas de comportement issu d'une conversion d'un pointeur sur fonction à un pointeur générique. Le bon fonctionnement d'une telle pratique est soumis à la disponibilité d'une extension de compilateur. Cette extension a été inhibée par le flag -pedantic.



Pour ma part :

Code :

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

1
2
3
4
5
6
typedef int (*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5]))[10];
int main(void)
{
    foo f;
    return 0;
}

Celui qui parvient à initialiser l'objet 'f' et l'utiliser convenablement recevra une médaille de ma part .

Une autre bizarrerie :
f1.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char * foo;
 
void f1(void)
{
      puts(foo);
}

f2.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char foo[50];
 
void f2(void)
{
      puts(foo);
}

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
char foo[50] = "Hello world";
extern void f1(void);
extern void f2(void);
 
int main(void)
{
      f1();
      f2();
      return 0;
}

N'hésitez pas à expliquer le bogue généré par ce petit programme si vous avez une explication. Une médaille est prévue pour le gagnant .

Et pour la route :

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
/*Ceci ne devrait pas choquer*/
int main(void)
{
       void foo(int [20]);
       int t1[50];
       int t2[6];
       int t3[20];
 
       foo(t1);
       foo(t2);
       foo(t3);
 
       return 0;
}
 
void foo(int t[20])
{
       t[0] = 0;
}

[Sve@r]

tu veux parler de
http://www.ioccc.org/main.html

Ouais c'est ça. C'est le concours des grands malades

En revanche le code que tu as donné ne compile pas chez moi...

Oui, désolé, j'ai posté ce code de mémoire suite à un truc que j'avais remarqué il y a fort longtemps ; et commis l'erreur de ne pas le tester. Merci de l'avoir rectifié au niveau de la déclaration de ptF.

Une autre bizarrerie :
f1.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char * foo;
 
void f1(void)
{
      puts(foo);
}

f2.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char foo[50];
 
void f2(void)
{
      puts(foo);
}

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
char foo[50] = "Hello world";
extern void f1(void);
extern void f2(void);
 
int main(void)
{
      f1();
      f2();
      return 0;
}

N'hésitez pas à expliquer le bogue généré par ce petit programme si vous avez une explication. Une médaille est prévue pour le gagnant

En fait, f2 est inutile car f1 suffit pour générer le bogue. C'est parce que, même si on peut les utiliser de façon similaire dans 98% des cas, un pointeur n'est pas un tableau. Et ton exemple fait partie des 2% qui le prouvent...

[gl]

Effectivement, le C standard ne définit pas de comportement issu d'une conversion d'un pointeur sur fonction à un pointeur générique. Le bon fonctionnement d'une telle pratique est soumis à la disponibilité d'une extension de compilateur. Cette extension a été inhibée par le flag -pedantic.

Et occasionnellement, on ne peut pas déréférencer un void*.

Une autre bizarrerie :
f1.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char * foo;
 
void f1(void)
{
      puts(foo);
}

f2.c

Code :

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

1
2
3
4
5
6
7
#include <stdio.h>
extern char foo[50];
 
void f2(void)
{
      puts(foo);
}

main.c

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
char foo[50] = "Hello world";
extern void f1(void);
extern void f2(void);
 
int main(void)
{
      f1();
      f2();
      return 0;
}

N'hésitez pas à expliquer le bogue généré par ce petit programme si vous avez une explication. Une médaille est prévue pour le gagnant .

Déclaration d'un extern avec un type différent de la définition.
Au passage, dans f2.c (et dans f1.c si on souhaite corriger le problème), extern char foo[]; suffit et est globalement plus simple à maintenir (en supposant que la globale soit justifiée bien sur).


Dans les classiques, qui n'est pas compliqué à comprendre mais qui surprend quand on tombe dessus la première fois (heureusement gcc correctement réglé les signale), il y a l'utilisation des trigraphes :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
??=include <stdio.h>
 
int main()
??<
	char tab??(??) = "abc";
 
	if(tab??(0??) == 'd' ??!??!tab??(0??) == 'a')
	??<
		printf("Hello!");
	??>
 
	return 0;
??>

[diogene]

typedef int (*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5]))[10];

C'est plutôt un exercice pour décoder les déclarations complexes en C :

Code :

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

1
2
3
4
5
6
 int (*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5]))[10]
(*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5]))  // est tableau de 10 int
*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5])  // est tableau de 10 int
(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5])  // est pointeur sur tableau de 10 int
(*foo)  //est fonction retournant un pointeur sur tableau de 10 int
// foo est pointeur sur fonction retournant un pointeur sur tableau de 10 int

Liste des arguments de cette fonction : void *(*)(void*foo),int(*(*foo)(void*foo))[5] . Tous ces foo ne sont que les noms optionels des paramètres.
Premier argument :

Code :

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

1
2
3
4
void *(*)(void*foo)
(*)(void*foo) // est pointeur sur void
(*) // est fonction retournant un pointeur sur void
// est pointeur sur fonction retournant un pointeur sur void, ayant pour argument un pointeur sur void

Deuxième argument :

Code :

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

1
2
3
4
5
6
int(*(*foo)(void*foo))[5]
(*(*foo)(void*foo)) //  est tableau de 5 int
*(*foo)(void*foo) // est tableau de 5 int
(*foo)(void*foo) // est pointeur sur tableau de 5 int
(*foo) // est fonction retournant un pointeur sur tableau de 5 int
// est pointeur sur fonction retournant un pointeur sur tableau de 5 int, ayant pour argument un pointeur sur void

Au final :
foo est un pointeur sur une fonction retournant un pointeur sur un tableau de 10 int dont le premier argument est un pointeur sur une fonction retournant un pointeur sur void et ayant pour argument un pointeur sur void, et le second argument est un pointeur sur fonction retournant un pointeur sur un tableau de 5 int et ayant pour argument un pointeur sur void

C'est équivalent à :

Code :

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

1
2
3
4
5
typedef int T10[10];
typedef int T5[5];
typedef void * TFoncA(void*);
typedef T5 * TFoncB(void*);
typedef T10 *(* foo)(TFoncA f1, TFoncB f2) ;

Application :

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
//---------------------------------------------------------------------------
typedef int T10[10];
typedef int T5[5];
typedef void * TFoncA(void*);
typedef T5 * TFoncB(void*);
typedef int (*(*foo)(void *(*)(void*foo),int(*(*foo)(void*foo))[5]))[10];
typedef T10 *(* foo)(TFoncA f1, TFoncB f2) ; // équivalent à la définition précédente
//---------------------------------------------------------------------------
void * foncA(void* a)
{
  return a;
}
//---------------------------------------------------------------------------
T5 * foncB(void* b)
{
  return b;
}
//---------------------------------------------------------------------------
T10 * fonc(TFoncA f1, TFoncB f2)
{
  return NULL;
}
//---------------------------------------------------------------------------
int main(void)
{
    T10 * p;
    foo f = fonc;
    p = f(foncA, foncB);
    return 0;
}
//---------------------------------------------------------------------------

Ai-je mérité une médaille ?

[ugo188]

Merci pour vos réponses!

En effet, il y a de bonnes choses dedans!

Je connaissais pas les trigraphes, c'est original.

EDIT:

Ai-je mérité une médaille ?

Je pense que oui

[uknow]

Ai-je mérité une médaille ?

Oui bien vu
D'ailleurs toutes les autres réponses la méritent.

Une des suggestions à faire pour les développeurs de GCC serait de signaler une déclaration incompatible avec la définition en ce qui concerne les tableaux. Surtout que la norme a assez décrit la combinaison de types, et des types dits compatibles.

C'est bien dommage qu'un code aussi incorrect passe à la compilation sans relever un petit quelque chose.

Même remarque que pour une fonction du genre :

Code :

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

1
2
3
4
5
6
7
int (*foo(void))[N]
{
       int t[N];
       int (*p)[N] = &t;
 
       return p;
}

Mais cela reviendrait à concevoir un analyseur de comportements indéfinis. Je pense que cela pourrait résoudre beaucoup de problèmes.

[DaZumba]

L'operateur virgule est superbe pour creer des programmes au comportement inattendu. Un de mes preferes est:

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
#include <stdio.h>
 
int main(void)
{
  int a[100];
  int i;
 
  for (i = 0; i < 100; ++i)
  {
    a[i] = (scanf,("%d", i));
    printf("%d\n", a[i]);
  }
 
  return 0;
}

[uknow]

L'oubli du & dans le scanf est-ce volontaire ?

En tout cas il y a pire :

Code :

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

1
2
3
i = i++;
//Ou
a[i++] = i;

[DaZumba]

L'oubli du & dans le scanf est-ce volontaire ?

Oui, le jeu est de realiser que scanf() n'est pas appellee. C'est vrai que les parentheses et le i au lieu de &i revelent le truc...

En tout cas il y a pire :

Code :

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

1
2
3
i = i++;
//Ou
a[i++] = i;

Ca, c'est du comportement indefini - mon exemple est parfaitement correct !

[gangsoleil]

L'operateur virgule est superbe pour creer des programmes au comportement inattendu. Un de mes preferes est:

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
#include <stdio.h>
 
int main(void)
{
  int a[100];
  int i;
 
  for (i = 0; i < 100; ++i)
  {
    a[i] = (scanf,("%d", i));
    printf("%d\n", a[i]);
  }
 
  return 0;
}

mon exemple est parfaitement correct !

Oui, mais un compilateur bien regle revele vite la supercherie :

test.c:10: attention : l'opérande à gauche de la virgule n'a pas d'effet

[Captain'Flam]

Le temps que je penche sur le problème, tout le monde m'est passé devant...
Mais bon, voici ma proposition quand même :

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 <string.h>
#include <stdio.h>
 
int (*foo2 ( void * foo )) [5]
    {
    static int res [5] ;
    memcpy( res,foo,5*sizeof( int )) ;
    return & res ;
    }
 
void * foo4 ( void * foo )
    {
    return foo ;
    }
 
int (* foo3 ( void *(*foo5) (void*foo) , int(*(*foo)(void*foo))[5] )) [10]
    {
    static int res [10] ;
    int data [5] = { 1,2,3,4,5 } ;
    int (*res2) [5] ;
    int i ;
 
    res2 = foo( foo5( data )) ;
    for ( i = 0 ; i < 5 ; ++i ) res[i] = res[i+5] = (*res2)[i] ;
 
    return & res ;
    }
 
typedef int (* (*foo) ( void *(*) (void*foo) , int(*(*foo)(void*foo))[5] ) ) [10] ;
 
int main(void)
    {
    int i ;
    int (*res) [10] ;
    foo f = foo3 ;
    res = f( &foo4,&foo2 ) ;
    for ( i = 0 ; i < 10 ; ++i ) printf("%d\n",(*res)[i] ) ;
    return 0 ;
    }

Tant pis pour la médaille

[Captain'Flam]

mais je trouve qu'on s'éloigne du sujet original de ugo188 à savoir des exemple de code à la syntaxe inattendue ou méconnue.
Son exemple (un peu étoffé ici)

Code :

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

1
2
3
4
5
6
7
8
9
int main ()
{
    int a [5] ;
    int b = 2 ;
    3[a] = 3 ;
    b[a] = 1 ;
    a[2][a] = 5 ;
    return 0 ;
}

est quand même assez stupéfiant !

En 20 ans de C, je n'avais jamais rencontré ça...
Personnellement je suis assez preneur de tels exemples.

[Obsidian]

tu veux parler de
http://www.ioccc.org/main.html

J'adore particulièrement, comme tout le monde, je crois, le programme du vainqueur du calcul de Pi en 1988 !

Sinon, cette citation, également :

15:15 j'ai la chaine de char "./foo" c quoi en C le plus simple pour
juste avoir "foo" ?
15:16 15:15 foo+2
15:21 15:16 ou alors &2[foo] , c'est rigolo aussi
15:24 15:21 et plus on &2[foo], plus on rit...

On peut citer aussi le swap de variables

Code C :

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

1
2
3
x ^= y;
y ^= x;
x ^= y;

… qui se « simplifie » en :

Code :

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

x ^= y ^= x ^= y ;

… (vu ici), ainsi que les cute codes tels que :

Code C :

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

c = "0123456789abcdef"[n];

…pour faire les conversions hexadécimales. :-)

[Sve@r]

Code :

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

1
2
3
4
5
6
7
8
9
int main ()
{
    int a [5] ;
    int b = 2 ;
    3[a] = 3 ;
    b[a] = 1 ;
    a[2][a] = 5 ;
    return 0 ;
}

J'ai tout compris... sauf la dernière ligne a[2][a]=5. a est un tableau 1D donc là je reste sec...

On peut citer aussi le swap de variables

Code C :

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

1
2
3
x ^= y;
y ^= x;
x ^= y;

Ca marche... jusqu'au jour où on fait ça dans une fonction dédiée en utilisant des pointeurs.

Code c :

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

1
2
3
4
5
6
void swap(int *x, int *y)
{
     (*x)^=(*y);
     (*y)^=(*x);
     (*x)^=(*y);
}

Puis, on l'appelle normalement

Code c :

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

1
2
3
4
5
6
7
int main()
{
      int a=5;
      int b=2;
      swap(&a, &b);
      printf("a et b valent %d, %d\n", a, b);
}

Jusque là, tout va bien. Puis, on l'appelle stupidement

Code c :

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

1
2
3
4
5
6
int main()
{
      int a=5;
      swap(&a, &a);
      printf("a vaut %d", a);
}

Et là, on se rend compte que, par la magie du xor, "a" a été mis à 0

[diogene]

sauf la dernière ligne a[2][a]=5. a est un tableau 1D donc là je reste sec...

.
La forme est trompeuse :

Comme x[y] == y[x] , on a a[2][a]== a[a[2]]

[Sve@r]

.
La forme est trompeuse :

Comme x[y] == y[x] , on a a[2][a]== a[a[2]]

Joli. Effectivement il y a de quoi marcher sur la tête.