Tout est dans le sujet.
J'ai un doute... !? y a-t-il réellement une différence et si oui quel est
l'impacte sur le code ?
Tout est dans le sujet.
J'ai un doute... !? y a-t-il réellement une différence et si oui quel est
l'impacte sur le code ?
Tout est dans le sujet.
J'ai un doute... !? y a-t-il réellement une différence et si oui quel est
l'impacte sur le code ?
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
Pierre Maurette a écrit :
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:
Pierre Maurette a écrit :
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:
Pierre Maurette a écrit :
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
xylo, le 04/06/2009 a écrit :Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
xylo, le 04/06/2009 a écrit :
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:
Pierre Maurette a écrit :
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
xylo, le 04/06/2009 a écrit :Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
Le Thu, 04 Jun 2009 10:23:50 +0200, Pierre Maurette a écrit:xylo, le 04/06/2009 a écrit :Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
CODE
****
#include <stdlib.h> /* pour calloc() */
#include <stdio.h> /* pour strncpy() */
//#include <string.h>
#define MAXSTRLEN 255
typedef enum ERR_TYPE {
noErr = 0,
memErr,
} ERR_TYPE;
int main(int argc, char **argv) {
ERR_TYPE err = noErr;
const char *pconstchar = NULL;
char const *pcharconst = NULL;
pconstchar = (const char *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pconstchar) { err = memErr; goto DONE;}
pcharconst = (char const *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pcharconst) { err = memErr; goto DONE;}
strncpy( pconstchar, "const char *pconstchar", MAXSTRLEN);
strncpy( pcharconst, "char const *pcharconst", MAXSTRLEN);
fprintf( stdout, "npconstchar: %s", pconstchar);
fprintf( stdout, "npcharconst: %s", pcharconst);
fprintf( stdout, "n");
fflush( stdout);
DONE:
free(pconstchar);
free(pcharconst);
return (noErr == err) ? EXIT_SUCCESS : EXIT_FAILURE;
}
COMPILATION
***********
gcc -c main.c -o main.o
main.c: In function 'main':
main.c:26: warning: incompatible implicit declaration of built-in function
'strncpy' main.c:26: warning: passing argument 1 of 'strncpy' discards
qualifiers from pointer target type main.c:27: warning: passing argument 1 of
'strncpy' discards qualifiers from pointer target type main.c:37: warning:
passing argument 1 of 'free' discards qualifiers from pointer target type
main.c:38: warning: passing argument 1 of 'free' discards qualifiers from
pointer target type gcc main.o -o test
QUESTION
********
Le compilo ne semble pas faire la différence si ce n'est qu'il émet
un warning sur les deux formes ?!
Le Thu, 04 Jun 2009 10:23:50 +0200, Pierre Maurette a écrit:
xylo, le 04/06/2009 a écrit :
Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:
Pierre Maurette a écrit :
Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
CODE
****
#include <stdlib.h> /* pour calloc() */
#include <stdio.h> /* pour strncpy() */
//#include <string.h>
#define MAXSTRLEN 255
typedef enum ERR_TYPE {
noErr = 0,
memErr,
} ERR_TYPE;
int main(int argc, char **argv) {
ERR_TYPE err = noErr;
const char *pconstchar = NULL;
char const *pcharconst = NULL;
pconstchar = (const char *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pconstchar) { err = memErr; goto DONE;}
pcharconst = (char const *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pcharconst) { err = memErr; goto DONE;}
strncpy( pconstchar, "const char *pconstchar", MAXSTRLEN);
strncpy( pcharconst, "char const *pcharconst", MAXSTRLEN);
fprintf( stdout, "npconstchar: %s", pconstchar);
fprintf( stdout, "npcharconst: %s", pcharconst);
fprintf( stdout, "n");
fflush( stdout);
DONE:
free(pconstchar);
free(pcharconst);
return (noErr == err) ? EXIT_SUCCESS : EXIT_FAILURE;
}
COMPILATION
***********
gcc -c main.c -o main.o
main.c: In function 'main':
main.c:26: warning: incompatible implicit declaration of built-in function
'strncpy' main.c:26: warning: passing argument 1 of 'strncpy' discards
qualifiers from pointer target type main.c:27: warning: passing argument 1 of
'strncpy' discards qualifiers from pointer target type main.c:37: warning:
passing argument 1 of 'free' discards qualifiers from pointer target type
main.c:38: warning: passing argument 1 of 'free' discards qualifiers from
pointer target type gcc main.o -o test
QUESTION
********
Le compilo ne semble pas faire la différence si ce n'est qu'il émet
un warning sur les deux formes ?!
Le Thu, 04 Jun 2009 10:23:50 +0200, Pierre Maurette a écrit:xylo, le 04/06/2009 a écrit :Le Thu, 04 Jun 2009 00:51:49 +0200, candide a écrit:Pierre Maurette a écrit :Donc dans
char const * const foo
ou
const char * const foo
foo est une constante qui pointe vers une (zone) constante.
Le purisme n'est pas là où tu crois :
foo est une _constante_ ? tu sais ce que c'est qu'une "constante" en C ?
ben oui, j'étais persuadé qu'il n'existait pas vraiment de notion de
contante en C mais plus tot une notion de lecture seule d'une variable
(donc d'un espace mémoire) ??
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const" ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const. Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales ont leur origine dans d'autres fils, à moins que ce ne soit plus
profond.
CODE
****
#include <stdlib.h> /* pour calloc() */
#include <stdio.h> /* pour strncpy() */
//#include <string.h>
#define MAXSTRLEN 255
typedef enum ERR_TYPE {
noErr = 0,
memErr,
} ERR_TYPE;
int main(int argc, char **argv) {
ERR_TYPE err = noErr;
const char *pconstchar = NULL;
char const *pcharconst = NULL;
pconstchar = (const char *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pconstchar) { err = memErr; goto DONE;}
pcharconst = (char const *)calloc(MAXSTRLEN+1, sizeof(char));
if(NULL == pcharconst) { err = memErr; goto DONE;}
strncpy( pconstchar, "const char *pconstchar", MAXSTRLEN);
strncpy( pcharconst, "char const *pcharconst", MAXSTRLEN);
fprintf( stdout, "npconstchar: %s", pconstchar);
fprintf( stdout, "npcharconst: %s", pcharconst);
fprintf( stdout, "n");
fflush( stdout);
DONE:
free(pconstchar);
free(pcharconst);
return (noErr == err) ? EXIT_SUCCESS : EXIT_FAILURE;
}
COMPILATION
***********
gcc -c main.c -o main.o
main.c: In function 'main':
main.c:26: warning: incompatible implicit declaration of built-in function
'strncpy' main.c:26: warning: passing argument 1 of 'strncpy' discards
qualifiers from pointer target type main.c:27: warning: passing argument 1 of
'strncpy' discards qualifiers from pointer target type main.c:37: warning:
passing argument 1 of 'free' discards qualifiers from pointer target type
main.c:38: warning: passing argument 1 of 'free' discards qualifiers from
pointer target type gcc main.o -o test
QUESTION
********
Le compilo ne semble pas faire la différence si ce n'est qu'il émet
un warning sur les deux formes ?!
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const"
ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const.
Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const"
ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const.
Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
Effectivement, j'aurais dû écrire "foo est concerné par le qualifieur
(hum) de type const"
ou plus simplement "foo est constant".
Notez quand même que si vous dites - ou écrivez - que var est une
constante float, tout le monde comprendra qu'il s'agit d'une variable
float type-qualified par const.
Dans la norme, une constante (a
constant) est une constante littérale, par exemple 2.0f dans:
float const x = 2.0f;
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
Pierre Maurette a écrit :
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
Pierre Maurette a écrit :
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
Pierre Maurette a écrit :
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
candide, le 04/06/2009 a écrit :Pierre Maurette a écrit :
[...]Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
Toujours bobo au cucu ?
candide, le 04/06/2009 a écrit :
Pierre Maurette a écrit :
[...]
Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
Toujours bobo au cucu ?
candide, le 04/06/2009 a écrit :Pierre Maurette a écrit :
[...]Ne vous laissez pas embrouiller par l'aigri de service, ses varices
anales
N'aggrave pas ton cas.
Toujours bobo au cucu ?