MODULE 5
---------------------------- --------------------- #include //pour le système () {... #include codes C ++ ...} --------- ---------------------------------------- devrait être remplacé par: ----- -------------------------------------------- #include //utilisation C ++ wrapper pour appeler des fonctions C à partir des programmes de C ... #include using namespace std; ... {Codes C ++ ...} ---------------------------------------- --------- Dans VC ++ /VC ++ .NET l'iostream.h (tête avec .h) ne sera plus valable.
Il devrait être C de la tête, de sorte qu'il se conforme à la norme. En plus âgé compilateur C ++ Borland, ça fonctionne toujours, mais pas bon, pas plus ... et pour la norme C /C ++ de la portabilité devrait poser aucun problème ou mieux vous lire Module23 au https://www.tenouk.com/Module23.html pour obtenir la grande image ...
Pour les codes, ils ont encore des codes C C: o) ================================= ======================================== ========== ================================================== ============= //Utilisation des indicateurs de conversion de nombre entier #include #include int main () {printf ("Divers format pour l'impression entier \\ n"); printf ("------------------------------------- \\ n"); printf ("% d \\ n", 455); printf ("% i \\ n", 455); //i même que d dans printf () printf ("% d \\ n", 455); printf ("% d \\ n", -455); printf ("% hd \\ n", 32000); printf ("% ld \\ n", 2000000000L); printf ("% o \\ n", 455); printf ("% u \\ n", 455); printf ("% u \\ n", -455); //- 455% est lu par u et convertie en la valeur de //unsigned 4294966841 entier de 4 octets printf ("% x \\ n", 455); printf ("% X \\ n", 455); système («pause»); return 0; } ------------------------------------------------- ------------------------------ //impression nombres à virgule flottante avec #include int //de virgule flottante conversion prescripteurs main () {printf ("nombres à virgule flottante impression avec \\ n"); printf ("virgule flottante indicateurs de conversion.
\\ n"); printf ("Comparer la sortie avec le code source \\ n \\ n"); printf ("1% e. \\ n", 1.234.567,89); printf (". 2% e \\ n", 1.234.567,89); printf ("3% e \\ n.", -1234567,89); printf ("4% E \\ n"., 1.234.567,89); printf (". 5% f \\ n", 1.234.567,89); printf ("6% g \\ n.", 1.234.567,89); printf (". 7% G \\ n", 1.234.
567,89); système («pause»); return 0; } ------------------------------------------------- -------------------------------- //des chaînes de caractères d'imprimerie et #include principal) {caractère char #include int (= 'UN'; chaîne char [] = "Ceci est une chaîne"; char * stringPtr = "Ceci est aussi une chaîne"; printf ("--------------------------------- \\ n"); printf ("--- Caractère et String format --- \\ n"); printf ("--------------------------------- \\ n \\ n"); printf ("% c printf (" \\ string nLateral \\ n "); printf ("% s \\ n "," Ceci est une chaîne "); printf (" \\ nUtilisation nom du tableau, le pointeur vers le premier réseau élément \\ n "); printf ("% s \\ n ", chaîne); printf (" pointeur \\ nUtilisation, pointant vers le premier caractère de la chaîne \\ n "); printf ("% s \\ n ", stringPtr), le système (" pause "); return 0;} ------------------------------------------- --------------------------------------- //Utilisation de la p, n, et la conversion de% prescripteurs #include #include int main () {int * ptr; //pointeur de variable int x = 12345, y; ptr = & x; //adresse attribution de la variable x à la variable ptr printf ("\\ nUtilisation p, n, et %% indicateurs de conversion de \\ n "); printf (".
Comparez la sortie avec le code source \\ n "); printf (" ---------------------- ------------------------- \\ n \\ n "); printf (" La valeur de pointeur ptr est% p \\ n ", ptr); printf ("L'adresse de la variable x est% p \\ n \\ n", et x); printf ("Nombre de caractères imprimés sur cette ligne est:% n", et y); printf ("% d \\ n \\ n", y ); y = printf ("Cette ligne dispose de 28 caractères \\ n"); printf ("d caractères% ont été imprimés \\ n \\ n", y); printf ("Impression d'une %% dans un contrôle de chaîne de format \\ n"); système («pause»); return 0; } ------------------------------------------------- -------------------------------- //Impression entiers justifié à droite #include #include int main () {printf ( "entiers d'impression justifiés à droite.
\\ n"); printf ("Comparer la sortie avec le code source \\ n"); printf ("--------------------------------------- \\ n \\ n"); printf ("M \\ n", 1); printf ("M \\ n", 12); printf ("M \\ n", 123); printf ("M \\ n", 1234); printf ("M \\ n \\ n", 12345); printf ("M \\ n", -1); printf ("M \\ n", -12); printf ("M \\ n", -123); printf ("M \\ n", -1234); printf ("M \\ n", -12345); système («pause»); return 0; } ------------------------------------------------- -------------------------------- //Utilisation de précision lors de l'impression des nombres entiers, //nombres à virgule flottante et les chaînes #include #include int main () {int i = 873; float f = 123,94536; [] = "Happy Birthday" de Char; printf ("Utilisation de précision lors de l'impression des nombres entiers, \\ n"); printf ("des nombres à virgule flottante, et les chaînes.
\\ n"); printf ("Comparer la sortie avec le code source \\ n"); printf ("---------------------------------------- \\ n \\ n"); printf ("Utilisation de précision pour les entiers \\ n"); printf ("\\ t% .4d \\ n \\ t% .9d \\ n \\ n", i, i); printf ("Utilisation de précision pour des nombres à virgule flottante \\ n"); printf ("\\ t% .3f \\ n \\ t% .3e \\ n \\ t% .3g \\ n \\ n", f, f, f); printf ("Utilisation de précision pour les chaînes \\ n"); printf ("\\ t% .
11s \\ n", s); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //Droite et gauche justifiant justifiant valeurs #include #include int main () {printf ("droit de justifier et de justifier les valeurs gauche. \\ n"); printf ("Comparer la sortie avec le code source.
\\ n"); printf ("-------------------------------------------- \\ n \\ n "); printf ("SDCF \\ n \\ n", "bonjour", 7, 'a', 1,23); printf ("% - 10s% -10D% -10C% -10f \\ n", "bonjour", 7, 'a', 1,23); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //nombre d'impression avec et sans le drapeau + #include #include int main () {printf ("numéros d'impression avec et sans le drapeau +.
\\ n"); printf ("Comparer la sortie avec le code source \\ n"); printf ("--------------------------------------------- \\ n \\ n "); printf ("% d \\ n% d \\ n", 786, -786); printf ("% + d \\ n% + d \\ n", 786, -786); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //Impression d'un espace valeurs avant signés //pas précédées par + ou - #include #include int main () {printf ("Impression d'un espace avant signé valeurs \\ n"); printf ("pas été précédée par + ou -n \\ n"); printf ("-------------------------------------- \\ n \\ n"); printf ("% d \\ n% d \\ n", 877, -877); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //o, X, X, et tout à virgule flottante spécificateur #include #include int main () {int c = 1427; flotteur p = 1427,0; printf ("o, X, X, et tout à virgule flottante prescripteurs \\ n"); printf ("Comparer la sortie avec le code source \\ n"); printf ("----------------------------------------- \\ n \\ n") ; printf ("% # o \\ n", c); printf ("% # x \\ n", c); printf ("% # X \\ n", c); printf ("\\ n% # g \\ n", p); printf ("% # G \\ n", p); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //Impression avec le drapeau 0 (zéro) remplit des zéros #include #include int main () {printf ("Impression avec le () drapeau 0 zéro remplit des zéros \\ n"); printf ("Comparer la sortie avec le code source \\ n"); printf ("----------------------------------------------- -------- \\ n \\ n "); printf ("% + 09d \\ n", 762); printf ("d", 762); printf ("\\ n"); système («pause»); return 0; } ------------------------------------------------- ---------------------------------- //entiers lecture #include #include int main () {int a, b, c, d, e, f, g; printf ("lecture entiers de l'entrée standard \\ n"); printf ("------------------------------------ \\ n \\ n"); printf ("Entrez sept entiers séparés par un espace:"); scanf ("% d% i% i% i% o% u x%", et un, et b, et c, & D, et E, et f, et g); printf ("L'entrée affiché comme entiers décimaux est: \\ n"); printf ("% d% d% d% d% d% d% d \\ n", a, b, c, d, e, f, g); système («pause»); return 0; } ------------------------------------------------- ----------------------------------- //numéros lecture virgule flottante #include #include int main () {float a, b, c; printf ("La lecture des nombres à virgule flottante \\ n"); printf ("Comparer la sortie avec le code source.
\\ n"); printf ("---------------------------------------- \\ n \\ n"); printf ("Entrez trois nombres à virgule flottante, séparés par un espace: \\ n"); scanf ("% e% f% g", et un, et b, et c); printf ("Voici les numéros entrés dans la plaine \\ n"); printf ("notation à virgule flottante: \\ n"); printf ("% f% f% f \\ n", a, b, c); système («pause»); return 0; } ------------------------------------------------- ----------------------------------- //caractères de lecture et chaînes #include #include int main () { omble x, y [20]; printf ("Entrez une chaîne:"); scanf ("% c% s", et x, y); printf ("L'entrée était: \\ n"); printf ("le caractère \\"% c \\ "", x); printf ("et la chaîne \\"% s \\ "\\ n", y); système («pause»); return 0; } ------------------------------------------------- ------------------------------------- //données d'entrée avec une largeur de champ #include #include int main () {int x, y; printf ("Entrez un nombre entier de six chiffres:"); scanf ("-% d", et x, y et); printf ("L'entrée des entiers étaient% d et% d \\ n", x, y); système («pause»); return 0; } ------------------------------------------------- ------------------------------------- //Lecture et caractères rejets à partir de l'entrée flux #include # include int main () {int mois1, day1, an1, mois2, day2, année2; printf ("Entrez une date sous la forme mm-dd-yy:"); //pad 0 pour deux champs et en supprimant les caractères - .
... scanf ("% d% * c% d% * c% d", et mois1, & day1, & an1); printf ("le mois d = jour = d = année d \\ n \\ n", mois1, day1, an1); printf ("Entrez une date sous la forme jj /mm /aa:"); //pad 0 pour deux champs et à rejeter le /caractères ... scanf ("% d% * c% d% * c% d", et mois2, & day2, & year2); printf ("le mois d = jour = d = année d \\ n", mois2, day2, année2); système («pause»); return 0; } ------------------------------------------------- -------------------------------------- //concaténation du int #include #include main () {système de cout ("pause"); return 0; } ------------------------------------------------- -------------------------------------- //imprimer l'adresse stockée dans une variable char * # include () {char * string = "tests de pointeur" #include int principale; système de cout ("pause"); return 0; } ------------------------------------------------- --------------------------------------- ////entrée opérateur de flux d'extraction à partir du clavier avec cin #include #include int main () {int x, y; cout cin >> x >> y; cout> s >> t; q = 10 * (s + t); cout //en utilisant '\\ n' pour nouvelle ligne cout cout cout système («pause»); } ------------------------------------------------- -------------------------------------------- //cout et cin exemple pour la fonction appel et tableau #include #include simple_calc float (flottant); void main (void) {float x = 3, y [4], somme = 0; int i; cout cout for (i = 1; i {cout cin >> y [i]; sum = somme + y [i]; //tableau} système de cout ("pause");} float simple_calc (float x) {float p ; p = (x * x); retour p;} ------------------------------------- ------- VC ++ /VC ++ .
NET -------------------------------------- ------------- //impression nombres à virgule flottante avec //virgule flottante indicateurs de conversion #include main () {printf ("nombres à virgule flottante impression avec \\ n"); printf ( "prescripteurs virgule flottante conversion. \\ n"); printf ("Comparer la sortie avec le code source \\ n \\ n"); printf ("1% e. \\ n", 1.234.567,89); printf ("2% e \\. n ", 1.234.567,89); printf (" 3% e. \\ n ", -1234567,89); printf (" 4% E \\ n "., 1.234.567,89); printf (" 5% f \\ n ", 1.234.567,89).; printf ("6% g. \\ n", 1.234.567,89); printf (".
7% G \\ n", 1.234.567,89);} --------------------------------------------------GCC----------------------------------------------------- /* Utilisation de la p, n et prescripteurs de conversion% * //*****************module5.c*************** **** /#include #include int main () {int * ptr; /* variable pointeur * /int x = 12345, y; ptr = & x; /* attribuant l'adresse de la variable x à la variable ptr * /printf (" \\ nUtilisation p, n, et %% indicateurs de conversion.
\\ n "); printf (" Comparer la sortie avec le code source \\ n "); printf (" -------------- --------------------------------- \\ n \\ n "); printf (" La valeur de pointeur ptr est% p \\ n ", ptr); printf (" L'adresse de la variable x est% p \\ n \\ n ", et x); printf (" Nombre de caractères imprimés sur cette ligne est:% n ", et y); printf ("% d n \\ n \\ ", y); y = printf (" Cette ligne dispose de 28 caractères \\ n "); printf (" d caractères% ont été imprimés \\ n \\ n ", y); printf (" Impression d'une %% dans un contrôle de la chaîne de format \\ n "); return 0;} =============================================================================================================.
h>.h>