Archives du mot-clé variables

intro

Expressions, Opérateurs (arithmétiques, relationnels, affectations…)

  • Expressions

Une expression est un calcul qui donne une valeur résultat.
Exemple : 2 + 4.
Une expression comporte des variables, des appels de fonction et
des constantes combinés entre eux par des opérateurs.

  • Opérateurs arithmétiques

Ces opérateurs s’appliquent à des valeurs entières ou réelles.
Ces opérateurs sont :
+ (addition), - (soustraction), * (produit), / (division),
% (reste de la division).

  • Logique booléenne

Le résultat est toujours 0 (faux) ou 1 (vrai).

télécharger ICI=>

intro

Langage C :Les fonctions d’entrée/sortie les plus utilisées en C

3) Les fonctions d’entrée/sortie les plus

 utilisées en C

Comme le langage C a été crée pour être indépendant du matériel sur lequel il est implanté,
les entrées sorties, bien que nécessaires à tout programme, ne font pas partie intégrante
du langage, c’est pour cela qu’on fait appel à des bibliothèques de fonctions de base,
standardisées au niveau des compilateurs. En voici les bibliothèques principales :

· Entrée et sortie de données : <stdio.h> 

· Traitement de chaînes de caractères : <string.h> 

· Fonctions d’aide générales - gestion de la mémoire : <stdlib.h> 

· Fonctions arithmétiques : <math.h> …

Comme on vient de voir, la bibliothèque standard <stdio.h> contient un ensemble de fonctions
qui assurent la communication entre l’ordinateur et l’extérieur. En voici les plus importantes :

printf() 

La fonction printf est utilisée pour afficher ou transférer du texte,  ou des valeurs de variables
vers le fichier de sortie standard stdout (par défaut l’écran).

Note : pour voir les code justement il vous faut les coller dans le bloc-note et Merci . 

Exemple1 :

Ecrivez la suite d’instructions dans un fichier source « exemple1 » :

#include <stdio.h>

#include <stdlib.h>

int main ()

{

int a = 2;

int b = 4;

printf(« %d fois %d est %d\n », a, b, a*b);

printf(« Fin du travail\n »);

system(« pause »);

return 0;

}

 

 

Exemple2 :

Taper dans un fichier source « exemple2 » le code ci-dessous, constatez que les numéros de lignes
ont été affichés ! (Outils, Options de l’Editeur et Affichage…) :

#include <stdio.h>

#include <stdlib.h>

int main ()

{

    float x = 10.1234; 

    double y = 20.1234567; 

    printf(« %f\n », x); 

    printf(« %f\n », y); 

    printf(« %e\n », x); 

    printf(« %e\n », y); 

    printf(« Fin du travail\n »);

    system(« pause »);

    return 0;

}

 

En Résumé, voici les spécificateurs de format de printf :

SYMBOLE TYPE IMPRESSION COMME
%d ou %i int entier relatif
%u int entier naturel (unsigned)
%c int caractère
%x int Entier en notation hexadécimale
%f double rationnel en notation décimale
%e ou %E double rationnel en notation scientifique (exponentielle)
%s char* chaîne de caractères

scanf() 

La fonction scanf est la fonction symétrique à printf, mais au lieu d’afficher, elle permet
de lire des variables; elle fonctionne pratiquement comme printf, mais en sens inverse.
Cette fonction reçoit des données à partir du fichier d’entrée standard stdin (le clavier par défaut),
ces données sont mémorisées aux adresses indiquées par &.

Exemple :

#include <stdio.h>

#include <stdlib.h>

int main ()

{

   int jour, mois, annee;

   scanf(« %d %d %d », &jour, &mois, &annee);

   printf(« le jour est: %d le mois est: %d l’annee est: %d\n », jour, mois, annee); 

   printf(« Fin du travail\n »);

   system(« pause »);

   return 0;

}

A l’exécution :

 

 

putchar() 

La commande putchar (‘a’) affiche le caractère « a » à l’écran (stdout), l’argument de cette
fonction est bien évidemment un caractère.

 

Exemple :

#include <stdio.h>

#include <stdlib.h>

int main ()

{

   char a = 225;

   char b = ‘e’;

   putchar(‘x’);   /* afficher la lettre x */

   putchar(‘\n’);  /* retour à la ligne    */

   putchar(‘?’);   /* afficher le symbole ? */

   putchar(‘\n’);  

   putchar(65);    /* afficher le symbole avec */

                   /* le code 65  (ASCII: ‘A’) */

   putchar(‘\n’);

   putchar(a);     /* afficher la lettre avec  */

                   /* le code 225 (ASCII: ‘ß’) */

   putchar(‘\n’);

   putchar(b);     /* affiche le contenu de la var b ‘e’ */

   putchar(‘\n’);

   printf(« \nFin du travail\n »); /* 2 retours à la ligne! */

   system(« pause »);

   return 0;

}

 

getchar() - puts(chaîne) et gets(chaîne)

- La fonction getchar, plus utilisée que putchar, permet de lire le prochain caractère du fichier
d’entrée standard stdin.

- La fonction puts(chaîne) affiche, à l’écran, la chaîne de caractères « chaîne » puis positionne
le curseur en début de ligne suivante.

- La fonction gets(chaîne) lecture d’une chaîne sur stdin. Tous les caractères peuvent être entrés,
y compris les blancs. La saisie est terminée par un retour chariot.

Exemple :

#include <stdio.h>

#include <stdlib.h>

int main ()

{ char a ;

char TEXTE[] = « Voici une premiere ligne. »;

puts(TEXTE);

puts(« Voici une deuxieme ligne. »);

printf(« Tapez un texte\n »);

gets(TEXTE);

puts(TEXTE);

//printf(« Tapez un caractere\n »);

a = getchar();

putchar(a);

putchar(‘\n’);

printf(« Fin du travail\n »);

system(« pause »);

return 0;

}

 

wps_clip_image-15818

Declaration et stockage de variables, constantes…

Une variable doit être définie, dans un programme, par une déclaration : on indique le nom que
l’on désire lui donner, son type (int, float, char…) pour que le compilateur sache quelle taille en
mémoire il doit lui réserver et les opérateurs qui peuvent lui être associés, mais aussi comment
elle doit être gérée (visibilité, durée de vie,…).

Les constantes

Exemple :

#define PI 3.14 ou const float pi=3.14;

code C

#include <stdio.h>

#include <stdlib.h>

#define PI 3.14 /* PI est une constante=3,14 */

// on peut aussi utiliser : const float PI=3.14;

int main ()

{

float P,R;

printf(« Entrez la valeur du rayon : « );

scanf(« %f », &R);

P=2*PI*R;

printf(« Le perimetre du cercle est : %f\n »,P);

printf(« Fin du travail\n »);

system(« pause »);

return 0;

}

La Declaration de variables simples

Exemple :

int i ; /* la variable i est déclarée comme étant entière */

int compteur = 0 ; /* on déclare et on initialise la variable */

float x, y ;

double VOLUME ; /* Attention, le C fait la différence entre minuscule et majuscule */

char touche_clavier ;

 

Declarations locales

Dans tout bloc d’instructions {…}, avant la première instruction, on peut déclarer des variables.
Elles seront alors « locales au bloc d’instructions » : elles n’existent qu’à l’intérieur du bloc
(on parle alors de la portée de ces variables qui est limitée au bloc ainsi que de la
durée de vie de ces mêmes variables qui sont en fait créées à l’entrée du bloc et libérées
à sa sortie).

 

Declarations globales

Une déclaration faite à l’extérieur d’un bloc d’instructions {…}, (en général en début du fichier)
est dite globale. La variable est stockée en mémoire statique, sa durée de vie est celle du programme.
Elle est visible de sa déclaration jusqu’à la fin du fichier.

 

Declaration de type

De nouveaux types de variables peuvent être déclarés à l’aide de typedef. Cela permet de donner
un nom à un type donné, mais ne crée aucune variable.

Exemple :

code C

#include <stdio.h>

#include <stdlib.h>

int main ()

{

typedef float prix;

typedef float quantite;

typedef float total;

prix a, b;

quantite x, y;

total z, t;

printf(« Entrez les prix a et b : « );

scanf(« %f %f », &a, &b);

printf(« Entrez les quantites x et y : « );

scanf(« %f %f », &x, &y);

z = a * x;

t= b * y;

printf(« Le total1 est : %f et Le total2 est : %f\n », z, t);

printf(« Fin du travail\n »);

system(« pause »);

return 0;

}

 Retour au sommaire  => 

moteur-bugatti-veyron

Thermodynamique classique

Definition :

La thermodynamique est la description macroscopique des propriétés de la matière en termes de grandeurs physiques spécifiques


Constat experimental :

Description macroscopique des propriétés de la matière en termes de grandeurs physiques spécifiques

Quelques paramètres (les grandeurs physiques) suffisent pour décrire les propriétés macroscopiques d’un système.

Definition :

Variables thermodynamiques : grandeur macroscopique mesurable qui sert à définir l’état d’un système.

Sommaire :

  • Introduction. Définitions. Variables
  • Gaz parfait.Modèle microscopique. Gaz réel.  voir vidéo =>
  • Transformations thermodynamiques
  • Chaleur et Travail. Premier principe de la thermodynamique.
  • Systèmes ouverts. Bilans d’énergie.
  • Entropie. Deuxième principe de la thermodynamique.
  • transferts thermiques.

Télécharger Le PDF En Cliquons ici