## Programmation en langage C/C++ (pour programmeur Java)

### L'utilisation de bibliothèques
Si écrit soi-même : `#include "LIBRARY_FILE"` sinon `#include <LIBRARY_FILE>`
### Les entrées sorties
`std::cout << "Hello, World!" << std::endl;`
Choisir plutôt `printf`de la classe `stdio.h`
### La compilation séparée
Le C++ et le C sont compatible. En C, on utilise les fichiers .h et .c et en C++ on utilise le .hpp et le .cpp.
### Les types de données
On retrouve les type simple : `int`, `float` ou `char`.
Un `int` sera sur 2 octets sur une machine 16 bits ou sur 4 octets sur une machine 32 ou 64 bits.
On peut souvent se contenter d’entiers dont la taille correspond à celle de la machine, mais nous avons aussi parfois de spécifier une taille précise. Nous pouvons le faire un utilisant la bibliothèque “stdint”. En C, nous importons la bibliothèque avec “#include <stdint.h>” et nous avons maintenant accès (entre autres) aux types suivants :

• uint8_t
• int8_t
• uint16_t
• int16_t
• uint32_t
• int32_t
• uint64_t
• int64_t

Un `u` en préfixe signifie unsigned.

Le type “**char**” en Java est sur 16 bits et encode les caractères en UTF‑16. En C/C++, le type “**char**” est en général sur 8 bits et est soit signé, soit non signé.

En C il n’y a pas de type “**boolean**” et on utilise un “**int**” à la place. Il n’y a pas non plus de “**true**” ou de “**false**” mais un “0” représente _faux_ et tout ce qui est différent de zéro représente **vrai**. En C++ le type bool, ainsi que les constantes “**true**” et “**false**” ont été ajoutés.
### Les variables
La déclaration de variables locales en C/C++ est la même qu’en Java. En plus des variables locales, C/C++ permet de déclarer des variables globales. Il suffit de déclarer ces variables en dehors des pro‑ cédures. Une variable globale est accessible par toutes les procédures de tous les fichiers “.c” ou “.cpp” de votre application.

Vous pouvez limiter la portée des variables globales en utilisant le modificateur “**static**” (par exemple “**static int** counter”). Dans ce cas, la variable n’est globale qu’au fichier dans lequel elle est déclarée et non au programme tout entier. Les variables globales doivent être évitées le plus possible, et si vous en avez vraiment besoin, limitez alors leur portée avec le modificateur “**static**”.

Si en C on doit déclarer le type de chaque variable explicitement, C++ est capable de faire de l’inférence de type. Utilisez pour cela le type “**auto**”.
### Les constantes
Historiquement, les constantes en C étaient déclarées avec la pseudo‑instruction “#define” du pré‑ processeur. Par exemple “#define MAX_INT 65535”. Le préprocesseur fera une substitution textuelle et remplacera simplement toutes les occurrences de “MAX_INT” par “65535”. Le principal défaut de cette construction c’est que la constante n’a pas de type et que la substitution textuelle peut être la source d’erreur difficile à trouver.
Avec le C++, nous pouvons déclarer des constantes avec les modificateurs “**const**” ou “**constexpr**".
### Les instructions de contrôle de flux
Les instructions de contrôle de flux telles que “**if**”, “**while**”, “**for**” ou “**switch**” sont pratiquement identiques en Java et en C/C++. Tout comme en Java, assurez‑vous d’ajouter les instructions “**break**” dans les “**switch**/**case**”.
### Les classes
En Java, les classes permettent de regrouper des attributs et des méthodes dans un nouveau type de données. En C/C++, si on n’a que des attributs et pas de méthode, on peut utiliser le type “struct”. Ce type permet de regrouper des attributs et est aussi disponible en C :
Exemple :

struct point {
	int x;
	int y;
}  myPoint =  {.x =  12,  .y =  42};

Si on souhaite ajouter des _méthodes_ à un type, nous pouvons le faire en C avec des pointeurs de fonctions, mais c’est une technique assez lourde et sujettes aux erreurs. On préfère passer à C++ qui propose un vrai concept de classes et d’objets.

Nous pouvons déclarer une classe (par exemple, dans un fichier “point.hpp”) de la manière suivante :

class Point { 
public: 
	Point(); 
	Point(int x, int y); 
	void Move(int dx, int dy); 
private: 
	int x_; 
	int y_;
};

La convention d’ajouter un underscore à la fin d’un attribut vient du “Google C++ Style Guide”. Nous implémentons ensuite les méthodes dans un fichier “point.cpp” :

#include "point.hpp"

Point::Point() {
	x_ = 0; 
	y_ = 0; 
}

Point::Point(int x, int y) {
	x_ = x; 
	y_ = y; 
} 

void Point::Move(int dx, int dy) {
	x_ += dx;
	y_ += dy;
}

### Les objets
En Java, tous les objets sont des références. En C++ on a le choix. Par défaut, un objet n’est pas une référence, mais bien est une variable qui contient tous les attributs et les références vers les méthodes.

Point p(20,23);

Avec le constructeur par défaut :

Point p;

Si on copie un objet, on copie effectivement tous les attributs :

Point q = p;

### Les fonctions

Contrairement à Java, les fonctions en C/C++ peuvent exister indépendament des classes.
Les méthodes sont appelées fonctions ou procédures en C/C++. En C++, les méthodes sont liées aux classes.

:::info
Une procédure est une fonction qui ne retourne rien. C'est-à-dire ```void```.
:::

int Max(int x, int y) {
    return x > y ? x : y;
}

#### Paramètres
Par défaut, en C++, les paramètres d'une fonction sont passés par valeur (copie), sauf pour les tableaux qui sont passés par référence.
Pour passer des paramètres par référence, il faut ajouter un ```&``` à côté du type.

int Swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

:::warning
Si on appelle ```Swap(x, y)``` avec des constantes (```Swap(1, 2)```). Le compilateur générera une erreur.
:::

Il est possible de passer des arguments par référence sans pouvoir les modifier dans la fonction avec ```const```.

void Find(const BigObject& o, int x) {
    ...
}

En C++ (et non en C), il est possible de définir des valeurs par défaut à un paramètre.

void Sort(Array& array, bool ascending=false) {
    ...
}

L'appelle de la fonction se fera alors comme ceci :

Sort(myArray);
Sort(myArray, true);
Sort(myArray, false);

### Les tableaux et les vecteurs

En C, un tableau est juste une séquence d'éléments en mémoire et il est représenté par l'adresse du premier élément. Si un ```int``` fait 4 Octets, un tableau de 10 ```int``` fera 40 octets. Il n'y a donc aucun moyen de connaître la taille d'un tableau.

Un tableau se déclare comme ceci :

int a[10];

Lorsque l'on passe un tableau en paramètre d'une fonction, celui-ci est passé par référence du premier élément. Comme C ne connaît pas la taille d'un tableau, il est possible de passer en paramètre sa taille.

bool IsPresent(int x, int array[], int length) {
    for(int i = 0; i < length, i++) {
        if (array[i] == x) return true;
    }
    return false;
}

#### Vecteurs

Afin d'éviter des erreurs lors de l'utilisation de tableaux, il est existe, en C++ uniquement, une structure similaire aux tableaux en Java nommée ```vector```.

bool isPresent(int x, std::vector<int>& v) {
    for (int i = 0; i < v.size(); i++) {
        if (v[i] == x) return true;
    }
    return false;
}

L'instruction foreach existe aussi en C++, elle est utilisable avec un vecteur et un tableau dont la taille est connue à la compilation (pas de tableau passé en paramètre de fonction).

bool isPresent(int x, std::vector<int>& v) {
    for (int a : v) {
        if (a == x) return true;
    }
    return false;
}

En C++, l’opérateur “[]” ne vérifie pas que l’index soit valide et on peut très bien lire ou écrirev au‑delà des limites du tableau. Si on souhaite une vérification au “run time”, on doit utiliser la méthode “at” au lieu de “[]”.
Les tableaux simples sont plus efficaces et prennent moins de place en mémoire et les vecteurs sont plus flexibles
### Les pointeurs
### L'héritage

## Architecture générale des ordinateurs

- Ordinateur
- Microprocesseur et microcontrôleur
- Unité centrale de traitement
- Principe de traitement de l'information
- Taxonomie de Flynn
- Architectures des jeux d'instructions
- Information et données
- Mémoire centrale
- Périphériques
- Placement d'un programme en mémoire

### Ordinateur

## Architecture interne

- Architecture ARM
- Exécution d'un programme informatique
- Composants internes des µP ARMv7
- Modes des CPU ARMv7
- Performances

## Traitement des nombres

## Programmation en langage assembleur ARM

## Traitement des interruptions

## Fonctions d'un noyau de système d'exploitation

## Entrées/sorties

## Architecture avancée

# Objectifs des travaux pratiques

- Assimilation de la matière étudiée dans les cours
- Mise en œuvre de µP et de systèmes embarqués
- Utilisation des outils de développement croisé pour des systèmes embarqués