Un topic pour un noob en C - Page 2

À ma connaissance le Pascal (enfin le Delphi, je ne sais pas si il en existe une autre variante récente) a des performances du même ordre de grandeur que le C++, donc bien au-dela du Java ou du C#. En revanche leurs syntaxes respectives ont effectivement toutes des avantages par rapport au C (et celle du C# a celui d'avoir piqué toutes les bonnes idées des concurrents ^^)

Tu dirais que l'idéal aurait été que le monde du développement adopte massivement Delphi et oublie le C++ et le C# ?

Heu nan, pas du tout.

Petit remontage car je bloque sur un truc :

Je sais qu'il est possible d'écrire des fonctions 'qui ne sont pas à un niveau près de profondeur' pour leurs parametres.
Je veux dire par là que :
void AfficherTab( const char *str)
serait équivalent à :
void AfficherTab( const char **str)
voire meme :
void AfficherTab( const char str[])

C'est encore un peu/beaucoup confus pour moi, alors si quelqu'un a de la doc là-dessus je suis prenneur
(Idem pour une petite explication magistrale )

Je ne suis pas sur d'avoir compris ta question, mais bon
un pointeur contient une adresse. Pour le processeur, une adresse ne pointe pas vers un type de données particulier.

Le C te force à dire vers quel type de données pointe un pointeur, mais c'est pour t'aider à ne pas faire de bétises.


Tu peux très bien faire:

char a=45;
int *b = (int *)&a;
float ***c = (float ***)b;
printf("%c",*(char*)c);

Jyaif (./35) :
Tu peux très bien faire:

char a=45;
int *b = (int *)&a;
float ***c = (float ***)b;printf("%c",*(char*)c);

Non. Tu ne respectes pas les règles d'aliasing là.

D'un autre coté le C est tellement archaique à ce niveau que c'est naturel de ne pas respecter ces règles

Je me disais bien que c'était pas tres clair ce que j'avais marqué

En fait, je sais plus où j'ai pu tomber sur un truc pareil, et aussi je me demande si ce n'était pas que pour un cas particulier.
Mais, si on peut simplifier l'idée, je dirai que ce que je cherche a faire est 'un dereferencement a N ou N+1 niveau de pointeurs'.

Par exemple :
Mettons qu'on manipule des chaines de caracteres, et que j'ai une fonction qui me les affiche :
void aff_Chars( const char *)
Si je lui passe un pointeur (du bon type) vers le premier element d'un tableau de chars, la fonction m'affichera cette chaine.
Mais maintenant, si au lieu de passer un pointeur, je passe a cette fonction un pointeur vers un pointeur de chars,
ou meme tout simplement une chaine brute (ca j'en suis beaucoup moins sûr), je voudrais savoir de quelle maniere
faire abstraction de ce pointeur (...de pointeur eventuellement/ou pas de pointeur du tout) ^^'

Je sais que c'est un peut se prendre la tete pour rien de prévoir deux types d'utilisations pour une fonction donnée mais ca m'interresse
Car si je me trompe pas, void ST_helpMsg( const char *) fonctionne comme ca par exemple
Et si c'est vraiment le cas, ca veut dire que ST_helpMsg est capable d'aller chercher une chaine en dereferençant autant de fois qu'il le faudra (ou pas) le pointeur qui lui est passé en parametre. C'est a peut pres ca non ?

Merci de vos éclaircissements

Edit > Dites-le moi si j'ai faux sur toute la ligne

very (./37) :
D'un autre coté le C est tellement archaique à ce niveau que c'est naturel de ne pas respecter ces règles

Et du coup ton programme va boguer si tu le compiles avec un GCC récent, sauf si tu utilises -fno-strict-aliasing.

Kevin Kofler (./36) :

Jyaif (./35) :
Tu peux très bien faire:

char a=45;
int *b = (int *)&a;
float ***c = (float ***)b;printf("%c",*(char*)c);

Non. Tu ne respectes pas les règles d'aliasing là.

oula, tu peux expliquer quel est le problème? J'ai rien compris au C on dirait

dès qu'Onur va découvrir ce topic, il va se faire une joie de le mettre en favoris pour me le citer à chaque fois qu'on a un différent

Ne perdons donc pas de temps:

ok, d'après wikipedia ces rêgles d'aliasing ont été introduite avec le C99 pour permettre de plus optimiser. C'est pas dans l'esprit du C ce genre de rêgles je trouve, mais bon...
http://en.wikipedia.org/wiki/Aliasing_(computing)#Conflicts_with_optimization

edit:
Et maintenant que j'y pense, c'est complètement stupide!
Si on a une structure, on ne peut plus avoir de pointeur sur le premier membre de la structure?

Les règles d'aliasing existaient déjà dans le C90. (Je vais corriger l'article. )

Pour l'histoire de la structure, si, le compilateur (enfin, au moins GCC) tient compte du fait que la structure commence par un membre de type X quand il décide ce qu'un X* peut aliaser (heureusement!).

Je me demandais de quoi vous parliez au début
Mais en lisant le wiki ca m'est revenu ces regles ^^'

Donc en fait ce que j'essai de faire c'est de contourner cette histoire d'aliasing mais du coup c'est un peu crado non ?

Edit > Mais je me demande si ce n'était pas un truc tout bete du genre :

void ma_Fonction ( char *carac)
{
  char caractere = *(&(carac));
}

Ainsi, si je passe un pointeur de pointeur a ma_Fonction ca devrait dereferencer jusqu'a trouver le caractere. Et ca marche aussi pour le cas où je passe une chaine brute me semble-t-il.
Mais y'a un truc qui m'intrigue : le compilateur ne va-t-il pas optimiser le '*(&(carac))' en 'carac' tout simplement ?
Chui perduuuuuuuuuu aidez-moiiiiiiiii xD

un truc que j'ai pas compris dans cette histoire d'aliasing...
si tu as:

void fonction1(char* b) {

}

et que tu fais

int *a = ...;
fonction((char*)a);

alors, lors de l'appel de fonction1, a et b pointent vers la même adresse => problème d'aliasing?


Bon sinon, concernant ta question:
la fonction ST_helpMsg( const char * str) ne déférence pas le pointeur "autant de fois qu'il le faudra", car la fonction ne peux pas savoir combien de fois il faut déférencer. Il faudrait que la fonction ait ce prototype: ST_helpMsg( const char * str, int nombreDeDeferencesAFaire)

Jyaif (./45) :
alors, lors de l'appel de fonction1, a et b pointent vers la même adresse => problème d'aliasing?

Ici non parce que char * peut aliaser tout. Mais si tu avais, mettons, int * et long *, alors oui, ce serait un problème d'aliasing.

Bon sinon, concernant ta question:la fonction ST_helpMsg( const char * str) ne déférence pas le pointeur "autant de fois qu'il le faudra", car la fonction ne peux pas savoir combien de fois il faut déférencer. Il faudrait que la fonction ait ce prototype: ST_helpMsg( const char * str, int nombreDeDeferencesAFaire)

Il faudrait plutôt appeler ST_helpMsg(*str); pour une déréférence, ST_helpMsg(**str); pour deux etc. tout simplement, c'est beaucoup plus simple et déjà possible.

Ok pour ST_helpMsg, j'étais pas sûr donc ca m'étonne pas
Mais ya un truc que j'ai pas dû comprendre alors :

void ma_Fonction( char **carac)

Pour avoir ce char, il me suffit juste d'écrire :
char a = *carac;
non ?

char a = **carac;
est invalide non ?

Kevin Kofler (./46) :

Bon sinon, concernant ta question:la fonction ST_helpMsg( const char * str) ne déférence pas le pointeur "autant de fois qu'il le faudra", car la fonction ne peux pas savoir combien de fois il faut déférencer. Il faudrait que la fonction ait ce prototype: ST_helpMsg( const char * str, int nombreDeDeferencesAFaire)

Il faudrait plutôt appeler ST_helpMsg(*str); pour une déréférence, ST_helpMsg(**str); pour deux etc. tout simplement, c'est beaucoup plus simple et déjà possible.

Ce dont il voulait parler (je crois ), c'est de faire une fonction qui déférence le bon nombre de fois un pointeur passé en paramètre. Avec ton example, c'est le programmeur qui s'en occupe.

Il est possible de déclarer plusieurs foncions portant le même nom mais possédant des paramètres différents ?

Dude (./47) :
Pour avoir ce char, il me suffit juste d'écrire :
char a = *carac;
non ?

char a = **carac;est invalide non ?

Non, il faut mettre les 2 étoiles.

Jyaif (./48) :
Ce dont il voulait parler (je crois ), c'est de faire une fonction qui déférence le bon nombre de fois un pointeur passé en paramètre.

Oui, mais ça ne sert à rien.

RAHHHHHHHHHHH !!!! Merci Kevin
Donc s'il faut bien les deux étoiles c'est a cause de ca que je confond tout
Jusque là je croyais qu'on ne pouvais dereferencer qu'une seule fois un pointeur

Merci a vous

• Dude part se faire fouetter

Thibaut (./49) :
Il est possible de déclarer plusieurs foncions portant le même nom mais possédant des paramètres différents ?

non, mais en C++ oui.

OK. J'avais mal pigé le post de Kevin.

On peut peut-être faire une fonction qui accepte un char et un char * avec une macro et typeof.

__builtin_types_compatible_p plutôt. Mais ni ça, ni typeof, ne sont du C standard.

Ouai en gros c'est crado ^^

haha... Kevin commence à comprendre l'interet de la surcharge?

... et on est même pas en 2010, que du bonheur.

As-tu déjà oublié concat.h?

C'est quoi ce truc illisible ? Ca fait quoi ?

Polymorphisme de fonctions (plusieurs fonctions portant le même nom avec des paramètres différents)

Ca permet de faire comme ETP (lol) au niveau de la concanétation de string, bref réaliser l'opérateur & de concanétation c'est marqué en commentaire au début de la source).