Initialisateur constant vu comme non-constant.

Version imprimable

12/01/2017, 16h14
Captain'Flam

Initialisateur constant vu comme non-constant.
Bonjour,

je suis en train de jouer avec le feu en transtypant des pointeur en fonctions en int et vice-versa, et pendant mes expériences, je suis tombé sur une erreur de compilation qui ne semble pas très logique :

Voici un bout de code qui compile sans problème :
Code:

1 2 3 void foo ( void ) {} void bar ( void ) {} int p = (int)foo + 3 ;
Mais si je change le + en * ou ^ , j'ai une "error: initializer element is not constant".

Ou si j'introduit un autre pointeur de fonction int p = (int)foo + (int)bar ;, j'ai la même erreur.

Pourquoi râle-t-il alors qu'il n'y a que des constantes dans les calculs ?

Pour info, j'ai les mêmes erreurs avec gcc et Visual Studio.

Bonjour,
je n'arrive pas à reproduire le problème. Avec le code :

Code:

1
2
3
4
5
6
7
8
void foo(void) {}
void bar(void) {}
 
int main(void)
{
  int r = (int) foo * (int) bar;
  return 0;
}

j'obtiens :

Code:

1
2
3
4
5
6
7
8
9
10
11
$ gcc -Wall -Wextra -g    i.c  -lm -o i
i.c: In function ‘main’:
i.c:6:11: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
   int r = (int) foo * (int) bar;
           ^
i.c:6:23: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
   int r = (int) foo * (int) bar;
                       ^
i.c:6:7: warning: unused variable ‘r’ [-Wunused-variable]
   int r = (int) foo * (int) bar;
       ^

Je suis sous linux64 et j'utilise gcc 6.2

12/01/2017, 16h29
ternel

foo, c'est le nom d'une fonction void(void). Il est convertible implicitement en pointeur vers cette fonction. donc void (*)(void).
(int) foo est un cast, donc essaye de convertir un pointeur de fonction en entier.
C'est illégal, en effet.
Je ne sais pas ce que tu essayes, mais ca n'a pas de sens.

Comme ca n'a pas de sens du tout, le compilateur peut s'embrouiller dans ses messages d'erreurs.
12/01/2017, 16h31
Captain'Flam

Pardon,

p doit être déclaré comme une globale (à l’extérieur des fonctions) !
12/01/2017, 16h37
Captain'Flam

Citation:

Envoyé par ternel

C'est illégal, en effet.

Pas si illégal que ça puisque le + 3 fonctionne...
12/01/2017, 16h39
Matt_Houston

Comportement indéterminé. Ça « fonctionne ».

Heu...
Code:

1 2 3 4 5 6 7 8 9 10 void foo ( void ) { printf("foo\n") ;} void bar ( void ) { printf("bar\n") ;} int p1 = (int)foo + 3 ; int p2 = (int)bar - 7 ; void main2 () { ((void(*)())(p1-3))() ; ((void(*)())(p2+7))() ; }
affiche bien
Code:

1 2 foo bar
et sans warning, avec Visual Studio (level 4) et gcc (version 5.3.0, avec -Wall -Wextra).

Et je ne comprends toujours pas pourquoi, avec + et - il n'y a aucune erreur, alors qu'avec * ou ^ il me parle d'initialisateur non constant...

Code:

1
2
3
4
5
6
7
8
9
10
11
#include <stdio.h>
 
void foo ( void ) { printf("foo\n") ;}
void bar ( void ) { printf("bar\n") ;}
int p1 = (int)foo + 3 ;
int p2 = (int)bar - 7 ;
 
int main() {
    ((void(*)())(p1-3))() ;
    ((void(*)())(p2+7))() ;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
~/devel $ uname -a
Linux tatsumaki 4.8.13-1-ARCH #1 SMP PREEMPT Fri Dec 9 07:24:34 CET 2016 x86_64 GNU/Linux
~/devel $ gcc --version
gcc (GCC) 6.2.1 20160830
Copyright (C) 2016 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
~/devel $ gcc -Wall -Wextra nimp.c
nimp.c:5:10: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 int p1 = (int)foo + 3 ;
          ^
nimp.c:5:10: error: initializer element is not constant
nimp.c:6:10: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast]
 int p2 = (int)bar - 7 ;
          ^
nimp.c:6:10: error: initializer element is not constant
nimp.c: In function ‘main’:
nimp.c:9:6: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
     ((void(*)())(p1-3))() ;
      ^
nimp.c:10:6: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast]
     ((void(*)())(p2+7))() ;
      ^

Voilà, voilà..

Merci de tes efforts Matt_Houston, mais si tu avais fait un peu attention, tu aurais vu que les erreurs que tu as sont dues à la taille des pointeurs vs taille des int.
Evidemment, mon code n'était pas portable en 64 bits.
Mais ça peut s'arranger :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #ifdef x64 typedef long long iptr ; #else typedef int iptr ; #endif void foo ( void ) { printf("foo\n") ;} void bar ( void ) { printf("bar\n") ;} iptr p1 = (iptr)foo + 3 ; iptr p2 = (iptr)bar - 7 ; int main() { ((void(*)())(p1-3))() ; ((void(*)())(p2+7))() ; }
et maintenant sur un linux 32 bits :
Code:

1 2 3 4 5 6 7 8 9 10 $ gcc --version gcc (Ubuntu 5.4.0-6ubuntu1~16.04.4) 5.4.0 20160609 Copyright (C) 2015 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. $ gcc nimp.c -Wall -Wextra $ ./a.out foo bar
et sur un linux 64 bits :
Code:

1 2 3 4 5 6 7 8 9 10 $ gcc --version gcc (Ubuntu 5.3.1-14ubuntu2.1) 5.3.1 20160413 Copyright (C) 2015 Free Software Foundation, Inc. This is free software; see the source for copying conditions. There is NO warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. $ gcc nimp.c -Dx64 -Wall -Wextra $ ./a.out foo bar
Je vois que tout le monde semble très contrarié que j'ose faire ce genre d’expérience...
Mais je ne prétends pas que c'est du code propre ou très portable ou très fiable.
J'ai déjà bossé sur des DSP Texas Instrument 16 bits sur lesquels les pointeurs de fonctions faisaient 20 bits, et là, j'aurais peut-être eu des problèmes...
En tous cas, pour l'instant, sous Visual Studio, mingw32, mingw64, Ubuntu 32 bits et Ubuntu 64 bits, ça passe sans warnings et sans problème.

Et ma question n'était pas : regardez mon horrible code et venez tous le critiquer avec un mépris consensuel...
Mais plutôt : Pourquoi ça passe avec + ou - et un entier, mais qu'avec * ou ^ et un autre pointeur, j'ai une "error: initializer element is not constant".
Et à cette question, je n'ai pas eu de réponse...

13/01/2017, 12h52
jopopmk

Citation:

Envoyé par Captain'Flam

[..] Mais je ne prétends pas que c'est du code propre ou très portable ou très fiable.[..]

Propre ? Portable ? Fiable ? Non, la question qu'on se pose c'est POURQUOI :mrgreen:

Maintenant, moi aussi je suis intéressé par une réponse à la question de base, même si ça me choque pas qu'on ne puisse faire que des additions/soustractions dans une opération avec une adresse.

Citation:

Envoyé par Captain'Flam

[...]
Et ma question n'était pas : regardez mon horrible code et venez tous le critiquer avec un mépris consensuel...
Mais plutôt : Pourquoi ça passe avec + ou - et un entier, mais qu'avec * ou ^ et un autre pointeur, j'ai une "error: initializer element is not constant".
Et à cette question, je n'ai pas eu de réponse...

Faire des tests c'est bien, même essentiel pour «comprendre ce qui se passe derrière». C'est une bonne démarche, mais c'est une démarche un peu vaine (ou du moins inutilement compliquée) si on n'utilise pas en même temps la doc. En l'occurrence, ici la doc serait la norme C, l'actuelle étant C11. C'est sans doute un bon moyen de l'approcher, même si elle est dense et parfois peu abordable.

Les points à vois dans la doc sont principalement :

peut-on caster un pointeur de fonction vers un autre type sans avoir de comportement indéfini ?
La réponse est oui, mais il y a des contraintes. On peut caster un pointeur sur fonction vers un autre pointeur sur fonction. Si le type d'arrivée n'est pas compatible avec le type de départ alors appeler cette fonction castée donne un UB. Si on le recaste vers le type de départ alors c'est comme si on n'avait rien fait, on retrouve notre pointeur d'origine, on peut appeler la fonction. Voilà, c'est le seul cast valide.
C'est une extension courante que de pouvoir caster un pointeur de fonction vers void *, tellement courante qu'elle est notée dans la norme. Mais cela reste une extension qui peut ou non être implémentée par le compilo.
peut-on faire de l'arithmétique de pointeur avec un pointeur de fonction ?
oui c'est ce qui permet d'avoir des tableaux de fonctions.
peut-on caster un pointeur de fonction vers un type entier ?
A priori non, mais les compilos le propose en extension. Quel que soit le type de pointeur pour éviter d'avoir besoin de directives préprocesseurs il existe les types intptr_t et uintptr_t. Ce sont des types entiers qui assurent que caster un pointeur vers ce type et recaster de ce type vers un pointeur redonnera le même pointeur. Par extension cela fonctionnera aussi pour les pointeurs de fonctions.
pourquoi y a-t-il une différence dans la norme entre pointeur sur objet et pointeur sur fonction ?
parce que la norme tient compte des machines à architecture harvard où la mémoire donnée est différente de la mémoire code.
toutes les opérations arithmétiques sur les pointeurs sont-elles valides ?
non. On ne peut faire de l'atithmétique sur les pointeurs que si le résultat est dans un objet ou 1 élément après. On ne peut déréférencer un pointeur que s'il est dans l'objet sinon on arrive à un UB.
c'est quoi une expression constante en C?
là je te laisse consulter la doc car l'explication est longue et le comportement particulier de const ne simplifie pas les choses. Mais en gros c'est simplement une valeur qu'on connaît au build time et qui est assurée de ne pas pouvoir changer. Les entiers doivent être initialisés avec des expression constantes entières uniquement. Un function designator n'est pas une expression constante enitère (bien qu'il s'agisse d'une adresse sur les plateformes classiques modernes). Cela change évidemment si l'initialisation concerne une variable locale, là il s'agit d'une initialisation au runtime.

Un petit mot encore, ton code
Citation:
Envoyé par Captain'Flam
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #include <stdio.h> #ifdef x64 typedef long long iptr ; #else typedef int iptr ; #endif void foo ( void ) { printf("foo\n") ;} void bar ( void ) { printf("bar\n") ;} iptr p1 = (iptr)foo + 3 ; iptr p2 = (iptr)bar - 7 ; int main() { ((void(*)())(p1-3))() ; ((void(*)())(p2+7))() ; }
ne compile pas chez moi :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 $ gcc -Wall -Wextra -o nimp nimp.c nimp.c:11:11: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] iptr p1 = (iptr)foo + 3 ; ^ nimp.c:11:11: error: initializer element is not constant nimp.c:12:11: warning: cast from pointer to integer of different size [-Wpointer-to-int-cast] iptr p2 = (iptr)bar - 7 ; ^ nimp.c:12:11: error: initializer element is not constant nimp.c: In function ‘main’: nimp.c:16:6: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast] ((void(*)())(p1-3))() ; ^ nimp.c:17:6: warning: cast to pointer from integer of different size [-Wint-to-pointer-cast] ((void(*)())(p2+7))() ; ^ $ gcc --version gcc (Ubuntu 6.2.0-7ubuntu11) 6.2.0 20161018

13/01/2017, 13h26
Captain'Flam

Merci picodev pour cette réponse fort argumentée. :ave:
En effet je passe un certain temps dans la norme...
Malheureusement, à cause de contraintes professionnelles, c'est plutôt dans C89 que C++14... :pleure:
Et pour ton code qui ne compile pas, essaie avec -Dx64 sur ta ligne de commande...
13/01/2017, 13h47
picodev

Citation:

Envoyé par Captain'Flam

Merci picodev pour cette réponse fort argumentée. :ave:
En effet je passe un certain temps dans la norme...
Malheureusement, à cause de contraintes professionnelles, c'est plutôt dans C89 que C++14... :pleure:
Et pour ton code qui ne compile pas, essaie avec -Dx64 sur ta ligne de commande...

Aaarg :furieux: pas C++14 mais C11 :)
pff … C89, une norme vieille de 28 ans … enfin, on ne fait pas toujours ce qu'on veut.
13/01/2017, 14h03
jopopmk

Citation:

Envoyé par picodev

Aaarg :furieux: pas C++14 mais C11 :)
pff … C89, une norme vieille de 28 ans … enfin, on ne fait pas toujours ce qu'on veut.

Je pense qu'il écrit "C++14" pour montrer le décalage avec la norme qu'il utilise, pas en référence à celle sur laquelle tu as basé ta réponse (même si ça mixe C et C++) ;)

Et le C89 c'est très bien !!!
13/01/2017, 16h23
Captain'Flam

Citation:

Envoyé par jopopmk

Je pense qu'il écrit "C++14" pour montrer le décalage avec la norme qu'il utilise

C'est exactement ça : je fais du C89 au boulot (contraintes de l'embarqué sur du matos antédiluvien... :aie:) et quand je me fais des outils perso, alors là, c'est C++ :yaisse1: (quoi que le 14 est encore un peu trop fort pour moi :oops:) ou python !