Discussion :

[madlove40]

bjr!
j'aimerais svp savoir quelle est la meilleur façon d'apprendre C pas a pas? jai lancer des recherches sur google mais souvent on tombe sur de sites qui ne sont pas destiné au vraie debutants (ce qui ne savent absolument rien de C) mais qui sont destines a ceux qui ont des notions de C ou ce qui veulent juste un petits coup de pouce.merci de m'aides svp
P.S je ne connait absolument rien a C

[Emmanuel Delahaye]

bjr!
j'aimerais svp savoir quelle est la meilleur façon d'apprendre C pas a pas? jai lancer des recherches sur google mais souvent on tombe sur de sites qui ne sont pas destiné au vraie debutants (ce qui ne savent absolument rien de C) mais qui sont destines a ceux qui ont des notions de C ou ce qui veulent juste un petits coup de pouce.merci de m'aides svp
P.S je ne connait absolument rien a C

La première chose à comprendre est qu'il n'existe pas de C/C++. Il y a C et il y C++. Ce sont 2 langages différents.

Il y a des références de tutoriels sur ce site et sur le mien.

[Thierry Chappuis]

Si ton but est d'apprendre à programmer en C, tu peux essayer de commencer par: Bien débuter en langage C et Initiation au langage C

Pour C/C++, comme Emmanuel te l'a dit, ce langage n'existe pas.

Thierry

[vg-matrix]

Voilà un tuto que j'utilise et qui m'aide beaucoup en C:
http://www-id.imag.fr/~svarrett/down...ly_cours_C.pdf

[Thierry Chappuis]

Voilà un tuto que j'utilise et qui m'aide beaucoup en C:
http://www-id.imag.fr/~svarrett/down...ly_cours_C.pdf

A la page 7, on a:

Code :

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

1
2
3
4
#include <stdio.h> // Directive de preprocesseur
void main() {
    printf("Hello world!");
}

Ca commence plutôt mal!

Thierry

[raptor70]

Pour le C++ : http://mindview.net/Books/TICPP/ThinkingInCPP2e.html

[Melem]

bjr!
j'aimerais svp savoir quelle est la meilleur façon d'apprendre C pas a pas? Merci de m'aider svp

Donc tu veux apprendre le C. Le C++ c'est une autre histoire. Il y a de C et de C++ mais pas de C/C++.

J'ai lancé des recherches sur google mais souvent on tombe sur de sites qui ne sont pas destinés au vrais débutants (ce qui ne savent absolument rien de C) mais qui sont destines a ceux qui ont des notions de C ou ce qui veulent juste un petits coup de pouce

La première chose dont tu auras besoin c'est bien sûr un tutoriel de C (j'en ai fais un). La deuxième qui n'est pas négligeable c'est un bon EDI (Environnement de Développement Intégré). En gros c'est un logiciel qui te permet de travailler (développer) avec ton langage favori. Pour le langage C, je recommande Code::Blocks qui est gratuit t très simple d'usage.

[nicolas.sitbon]

A la page 7, on a:

Code :

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

1
2
3
4
#include <stdio.h> // Directive de preprocesseur
void main() {
    printf("Hello world!");
}

Ca commence plutôt mal!

Thierry

Dans http://melem.developpez.com/langagec/initc/ que tu proposes :

De plus on peut :

* Ne pas déclarer une fonction retournant un int (déconseillé).

Dans une définition (implémentation) :

* On peut ne pas préciser le type de retour d'une fonction. Dans ce cas celle-ci est supposée retourner un int.

* Une paire de parenthèses vide signifie que la fonction n'accepte aucun argument.

Autres remarques :

* La déclaration d'une fonction n'est nécessaire que lorsque son utilisation précède sa définition. Cependant, il est toujours conseillé de ne définir une fonction qu'après son utilisation (ce qui requiert donc une déclaration) ne serait-ce que pour la lisibilité du programme (en effet c'est le programme qu'on veut voir à première vue, pas les petits détails).

* Une fonction peut ne pas retourner de valeur. Son type de retour est alors void.

A REVOIR!!!

et je ne parle pas du

Code :

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

int main ()

que l'on retrouve un peu partout...

[Vincent Rogier]

et je ne parle pas du

Code :

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

int main ()

que l'on retrouve un peu partout...

Et alors ?

int main() ou plutôt int main(void) est totalement juste.

Extrait de la norme ISO C (ISO/IEC 9899:TC2)

5.1.2.2.1 Program startup

1 The function called at program startup is named main. The implementation declares no
prototype for this function. It shall be defined with a return type of int and with no
parameters:

int main(void) { /* ... */ }

or with two parameters (referred to here as argc and argv, though any names may be
used, as they are local to the function in which they are declared):

int main(int argc, char *argv[]) { /* ... */ }

or equivalent or in some other implementation-defined manner.

[nicolas.sitbon]

Et alors ?

int main() ou plutôt int main(void) est totalement juste.

)

et justement non, il y a une différence :

Code :

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

int main ()

est une déclaration de fonction alors que

Code :

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

int main (void)

est une déclaration plus un prototype.

A ce sujet, un compilateur correctement réglé (voir le site d'Emmanuel Delahaye) ne vous le pardonnera pas

error : fonction declaration isn't a prototype

Tu fais bien de citer la norme puisque depuis C99 le prototype d'une fonction est obligatoire.
Enfin, la partie de la norme qui dit :

or equivalent or in some other implementation-defined manner.

est expliqué juste en dessous :

Thus, int can be replaced by a typedef name defined as int, or the type of argv can be written as
char ** argv, and so on.

(informative)
Common warnings
1 An implementation may generate warnings in many situations, none of which are
specified as part of this International Standard. The following are a few of the more
common situations.

....

— A function is called but no prototype has been supplied (6.5.2.2).

[Thierry Chappuis]

et justement non, il y a une différence :

Code :

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

int main ()

est une déclaration de fonction alors que

Ben non, ce n'est pas seulement une déclaration, c'est une définition (qui inclut une déclaration, bien que pas sous forme de prototype). La norme spécifie qu'une déclaration avec une liste vide d'argument et qui fait partie d'une définition spécifie que cette fonction ne prend aucun argument. C'est ce qu'on veut et cette définition ne me choc donc pas, car parfaitement valide.

Thierry

[nicolas.sitbon]

La norme spécifie qu'une déclaration avec une liste vide d'argument et qui fait partie d'une définition spécifie que cette fonction ne prend aucun argument.

Peux tu me donner le passage de la norme qui le dit?

D'autre part, pourquoi GCC le sanctionne t'il?

[nicolas.sitbon]

D'autre part dans l'ouvrage de Achille Braquelaire, on trouve p17 :

Avec les précédentes versions du langage C, la déclaration des fonctions ou des paramètres de fonction de types int était facultative. Par exemple, la déclaration "f(x){..." était équivalente à la déclaration actuelle "int f(int x){...". cette tolérance a été retirée de la norme C99.

[emprex]

bjr!
j'aimerais svp savoir quelle est la meilleur façon d'apprendre C pas a pas? jai lancer des recherches sur google mais souvent on tombe sur de sites qui ne sont pas destiné au vraie debutants (ce qui ne savent absolument rien de C) mais qui sont destines a ceux qui ont des notions de C ou ce qui veulent juste un petits coup de pouce.merci de m'aides svp
P.S je ne connait absolument rien a C

Suis les cours et tutoriels pour apprendre C et aussi la FAQ C.

[Emmanuel Delahaye]

D'autre part dans l'ouvrage de Achille Braquelaire, on trouve p17 :

On est d'accord que l'indication explicite du type retourné est maintenant obligatoire. Mais tu parles de la validité de l'expression

Code :

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

1
2
3
4
 
int f()
{
}

La norme précise bien que lors de la définition d'une fonction (et la déclaration implicite qui en découle), les parenthèses vides constituent une indication comme quoi la fonction n'a pas de paramètres.

Par contre, cette forme de définition n'étant pas un prototype, certains compilateurs le font remarquer :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void f ()
{
}
 
int main (void)
{
   f ();
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : D:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c:2: warning: function declaration isn't a prototype
Linking console executable: console.exe
Process terminated with status 0 (0 minutes, 0 seconds)
0 errors, 1 warnings

C'est une mise en garde contre le risque de mauvais usage. En effet, il est techniquement possible de coder :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void f ()
{
}
 
int main (void)
{
   f (123);
   return 0;
}

Ce qui ne provoque ni remarques supplémentaires de la part du compilateur, ni comportement indéterminé, mais qui est probablement une erreur de codage. (Pourquoi passer un paramètre si il n'est pas utilisé ?)

C'est pourquoi il est recommandé d'utiliser la forme prototypale :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void f (void)
{
}
 
int main (void)
{
   f (123);
   return 0;
}

car cette fois, le défaut est signalé par le compilateur :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
Project   : Forums
Compiler  : GNU GCC Compiler (called directly)
Directory : D:\dev\forums\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `main':
main.c:7: error: too many arguments to function `f'
Process terminated with status 1 (0 minutes, 0 seconds)
1 errors, 0 warnings

Voilà pour le cas général. Concernant main(), en principe, on ne devrait pas appeler main() dans un programme, donc la forme simple main() devrait suffire et le compilateur pourrait ne rien dire. Mais le cas général semble avoir été appliqué par gcc, notamment, ce qu'il incite à utiliser la forme prototypale de main(void), ce qui est finalement une Bonne Chose.

Conclusion.

Il est tout à fait autoriser et sans danger d'utiliser main() si on est certain qu'il ne sera jamais appelé.

Il est simple et clair d'utiliser main(void), car ça couvre les cas tordus et ça fait taire le compilateur... Je recommande cette forme.

[nicolas.sitbon]

Ok, maintenant que penser de ça :

Dans une définition (implémentation) :

* On peut ne pas préciser le type de retour d'une fonction. Dans ce cas celle-ci est supposée retourner un int.

D'autre part dans l'ouvrage de Achille Braquelaire, on trouve p17 :

Avec les précédentes versions du langage C, la déclaration des fonctions ou des paramètres de fonction de types int était facultative. Par exemple, la déclaration "f(x){..." était équivalente à la déclaration actuelle "int f(int x){...". cette tolérance a été retirée de la norme C99.

[Emmanuel Delahaye]

Peux tu me donner le passage de la norme qui le dit?

Je te laisse fouiller...

6.9.1 Function definitions
Syntax
1 function-definition:
declaration-specifiers declarator declaration-listopt compound-statement
declaration-list:
declaration
declaration-list declaration
Constraints
2 The identifier declared in a function definition (which is the name of the function) shall
have a function type, as specified by the declarator portion of the function definition.141)
3 The return type of a function shall be void or an object type other than array type.
4 The storage-class specifier, if any, in the declaration specifiers shall be either extern or
static.
5 If the declarator includes a parameter type list, the declaration of each parameter shall
include an identifier, except for the special case of a parameter list consisting of a single
parameter of type void, in which case there shall not be an identifier. No declaration list
shall follow.
6 If the declarator includes an identifier list, each declaration in the declaration list shall
have at least one declarator, those declarators shall declare only identifiers from the
identifier list, and every identifier in the identifier list shall be declared. An identifier
declared as a typedef name shall not be redeclared as a parameter. The declarations in the
declaration list shall contain no storage-class specifier other than register and no
initializations.
7 The declarator in a function definition specifies the name of the function being defined
and the identifiers of its parameters. If the declarator includes a parameter type list, the
list also specifies the types of all the parameters; such a declarator also serves as a
function prototype for later calls to the same function in the same translation unit. If the
declarator includes an identifier list,142) the types of the parameters shall be declared in a
following declaration list. In either case, the type of each parameter is adjusted as
described in 6.7.5.3 for a parameter type list; the resulting type shall be an object type.
8 If a function that accepts a variable number of arguments is defined without a parameter
type list that ends with the ellipsis notation, the behavior is undefined.
9 Each parameter has automatic storage duration. Its identifier is an lvalue, which is in
effect declared at the head of the compound statement that constitutes the function body
(and therefore cannot be redeclared in the function body except in an enclosed block).
The layout of the storage for parameters is unspecified.
10 On entry to the function, the size expressions of each variably modified parameter are
evaluated and the value of each argument expression is converted to the type of the
corresponding parameter as if by assignment. (Array expressions and function
designators as arguments were converted to pointers before the call.)
11 After all parameters have been assigned, the compound statement that constitutes the
body of the function definition is executed.
12 If the } that terminates a function is reached, and the value of the function call is used by
the caller, the behavior is undefined.
13 EXAMPLE 1 In the following:
extern int max(int a, int b)
{
return a > b ? a : b;
}
extern is the storage-class specifier and int is the type specifier; max(int a, int b) is the
function declarator; and
{ return a > b ? a : b; }
is the function body. The following similar definition uses the identifier-list form for the parameter
declarations:

extern int max(a, b)
int a, b;
{
return a > b ? a : b;
}
Here int a, b; is the declaration list for the parameters. The difference between these two definitions is
that the first form acts as a prototype declaration that forces conversion of the arguments of subsequent calls
to the function, whereas the second form does not.
14 EXAMPLE 2 To pass one function to another, one might say
int f(void);
/* ... */
g(f);
Then the definition of g might read
void g(int (*funcp)(void))
{
/* ... */
(*funcp)(); /* or funcp(); ... */
}
or, equivalently,
void g(int func(void))
{
/* ... */
func(); /* or (*func)(); ... */
}

-----------
141) The intent is that the type category in a function definition cannot be inherited from a typedef:
typedef int F(void); // type F is ‘‘function with no parameters
// returning int’’
F f, g; // fand g both have type compatible with F
F f { /* ... */ } // WRONG: syntax/constraint error
F g() { /* ... */ } // WRONG: declares that g returns a function
int f(void) { /* ... */ } // RIGHT: f has type compatible with F
int g() { /* ... */ } // RIGHT: g has type compatible with F
F *e(void) { /* ... */ } // e returns a pointer to a function
F *((e))(void) { /* ... */ } // same: parentheses irrelevant
int (*fp)(void); // fp points to a function that has type F
F *Fp; //Fp points to a function that has type F
142) See ‘‘future language directions’’ (6.11.7).
142 Language §6.9.1

(pour plus de clarté, j'ai déplacé les notes de bas de page à la fin...)

[Emmanuel Delahaye]

Ok, maintenant que penser de ça :

Que le document cité concerne C90...

[nicolas.sitbon]

Que le document cité concerne C90...

D'accord, maintenant quel comportement doit on avoir dans ce cas là?
Je veux dire par là, quel version de la norme fait autorité?

[Emmanuel Delahaye]

D'accord, maintenant quel comportement doit on avoir dans ce cas là?
Je veux dire par là, quel version de la norme fait autorité?

Celle que tu choisis d'utiliser.