Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux,
typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux,
typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux,
"Xavier Combelle" a écrit dans le message de
news:40976db9$0$17919$Bonjour a tous,
Salut,D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT et d'avoir fourni vraiment
toutes les opérations nécessaires s'y rapportant. Par contre, un #define
pour une taille de tableau plutot que 10, c'est bien.Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
a_afficher est un pointeur sur tableau de char (j'aurais préféré
#define MAX 10
char (*a_afficher)[MAX]; ),/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
OK./* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
OK./* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
t est de type tableau de char, pas de type pointeur sur tableau de char,
types incompatibles.printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Appele( &t[0]); marche mais le type est toujours incompatible comme avec le
premier printf, car Appele prend un pointeur de tableau en paramètre. Le
mieux, c'est d'utiliser uniquement le type tTableau, sans pointeurs.
Si ca marche, c'est que t est promu en pointeur sur tableau (tTableau) lors
de l'appel de Appele mais reste l'adresse du premier élément de t.
L'indirection est alors valide dans Afficher.
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
OK.int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
"Xavier Combelle" <xavier_combelle@yahoo.fr> a écrit dans le message de
news:40976db9$0$17919$626a14ce@news.free.fr...
Bonjour a tous,
Salut,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT et d'avoir fourni vraiment
toutes les opérations nécessaires s'y rapportant. Par contre, un #define
pour une taille de tableau plutot que 10, c'est bien.
Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
a_afficher est un pointeur sur tableau de char (j'aurais préféré
#define MAX 10
char (*a_afficher)[MAX]; ),
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
OK.
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
OK.
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
t est de type tableau de char, pas de type pointeur sur tableau de char,
types incompatibles.
printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Appele( &t[0]); marche mais le type est toujours incompatible comme avec le
premier printf, car Appele prend un pointeur de tableau en paramètre. Le
mieux, c'est d'utiliser uniquement le type tTableau, sans pointeurs.
Si ca marche, c'est que t est promu en pointeur sur tableau (tTableau) lors
de l'appel de Appele mais reste l'adresse du premier élément de t.
L'indirection est alors valide dans Afficher.
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
OK.
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
"Xavier Combelle" a écrit dans le message de
news:40976db9$0$17919$Bonjour a tous,
Salut,D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT et d'avoir fourni vraiment
toutes les opérations nécessaires s'y rapportant. Par contre, un #define
pour une taille de tableau plutot que 10, c'est bien.Xavier
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
a_afficher est un pointeur sur tableau de char (j'aurais préféré
#define MAX 10
char (*a_afficher)[MAX]; ),/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
OK./* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
OK./* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
t est de type tableau de char, pas de type pointeur sur tableau de char,
types incompatibles.printf ("f1: en pannen"); Appele( &t); }
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Appele( &t[0]); marche mais le type est toujours incompatible comme avec le
premier printf, car Appele prend un pointeur de tableau en paramètre. Le
mieux, c'est d'utiliser uniquement le type tTableau, sans pointeurs.
Si ca marche, c'est que t est promu en pointeur sur tableau (tTableau) lors
de l'appel de Appele mais reste l'adresse du premier élément de t.
L'indirection est alors valide dans Afficher.
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
OK.int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
pour info, voici le resultat de la compilation
et de l'execution.
% gcc -o tab -ansi -pedantic -Wall -W tab.c
tab.c: In function `Fonction1':
tab.c:12: warning: passing arg 1 of `Appele' from incompatible pointer type
tab.c:13: warning: passing arg 1 of `Appele' from incompatible pointer type
% tab
f1: fonctionne
valeur : hello
f1: en panne
valeur : Ð÷ÿ¿<øÿ¿è÷ÿ¿lhello
f2:
valeur : hello
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
pour info, voici le resultat de la compilation
et de l'execution.
% gcc -o tab -ansi -pedantic -Wall -W tab.c
tab.c: In function `Fonction1':
tab.c:12: warning: passing arg 1 of `Appele' from incompatible pointer type
tab.c:13: warning: passing arg 1 of `Appele' from incompatible pointer type
% tab
f1: fonctionne
valeur : hello
f1: en panne
valeur : Ð÷ÿ¿<øÿ¿è÷ÿ¿lhello
f2:
valeur : hello
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Quelqu'un peut-il me donner une solution
pour que le code fonctionne, de facon "logique"
et sans utiliser de char* ?
#include <stdio.h>
typedef char tTableau [10];
tTableau *a_afficher;
/* prototype fixe */
void Afficher(void) {
printf("valeur : %sn" , *a_afficher);
}
/* j'ai le droit de modifier
le prototype de cette fonction */
static void Appele(tTableau *t)
{ a_afficher = t;
Afficher();}
/* prototype fixe */
void Fonction1( tTableau t)
{ printf ("f1: fonctionnen"); Appele (t);
printf ("f1: en pannen"); Appele( &t); }
/* prototype fixe */
void Fonction2(tTableau *t)
{printf("f2: n"); Appele(t); }
int main ()
{
tTableau val = "hello";
Fonction1(val);
Fonction2(&val);
return 0;
}
pour info, voici le resultat de la compilation
et de l'execution.
% gcc -o tab -ansi -pedantic -Wall -W tab.c
tab.c: In function `Fonction1':
tab.c:12: warning: passing arg 1 of `Appele' from incompatible pointer type
tab.c:13: warning: passing arg 1 of `Appele' from incompatible pointer type
% tab
f1: fonctionne
valeur : hello
f1: en panne
valeur : Ð÷ÿ¿<øÿ¿è÷ÿ¿lhello
f2:
valeur : hello
Par contre,
un #define pour une taille de tableau plutot que 10, c'est bien.
Par contre,
un #define pour une taille de tableau plutot que 10, c'est bien.
Par contre,
un #define pour une taille de tableau plutot que 10, c'est bien.
En c785g0$pr1$, Régis Troadec va escriure:typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
Non. t est de type pointeur vers char.
(Et on devrait pendre celui qui force ce genre de prototype).
En c785g0$pr1$1@news-reader1.wanadoo.fr, Régis Troadec va escriure:
typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
Non. t est de type pointeur vers char.
(Et on devrait pendre celui qui force ce genre de prototype).
En c785g0$pr1$, Régis Troadec va escriure:typedef char tTableau [10];
void Fonction1( tTableau t)
t est de type tableau de char, [...]
Non. t est de type pointeur vers char.
(Et on devrait pendre celui qui force ce genre de prototype).
Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Bonjour a tous,
D'habitude, lorsque je passe des tableau
de caractères en paramètre, je les passe
a des fonctions dont le prototype est: void f(char *t).
Mais dans le cas qui nous occupe,
je ne peux pas modifier le prototype
de certaine fonctions.
Pour que mon code fonctionne, je dois
retirer le '&' par rapport
à ce que je pensais être le
passage de paramètre par référence correct.
Quelqu'un peut-il m'expliquer pourquoi ?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT
Ca veut dire quoi ADT ?
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Ca veut dire quoi UB?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT
Ca veut dire quoi ADT ?
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Ca veut dire quoi UB?
Ce n'est généralement pas très bon de cacher les pointeurs (ni les
tableaux), à moins AMHA de définir son propre ADT
Ca veut dire quoi ADT ?
Avec les tableaux, le nom du tableau représente déjà l'adresse du premier
élément, t est équivalent à &t[0]. Je crois même que c'est un UB ici, t
n'est pas une lvalue, tu ne peux pas appliquer l'opérateur de prise
d'adresse &.
Ca veut dire quoi UB?