ça doit pas mal dépendre du compilo et de la manière dont il gère ça. Donc le mieux est de regarder le code assembleur généré par le compilo pour voir comment ça marche.

Globalement ça se fait à grand coup de and, or, shl et sar. Donc c´est pas catastrophique (peut-être 4 fois plus d´opération si on a pas de chance, mais là encore, il optimise pas mal).

Et une question par rapport à ta source JY².
J´avais crus lire quelque part qu´on ne pouvait effectuer ce genre d´opération qu´au sein des structures et classes.

Est-ce possible de faire cela :

int main() {
int a:4, b:16;

return 0;
}
Et donc du coup : int a:4; <=> char a;
Le temps d´opération de int a:4; et de char a; est-il le même ?? ?
Au quel cas, ce peut-être un bon outil pour la gestion de la mémoire, mais à manipuler avec précaution (ne serait-ce que pour les débordements de mémoires abusifs).

un char fait 8 bits et pas 4. Mais pour la question, je n´en sais rien. Le mieux est peut-être de faire le test.

On ne peut le faire que dans les structures et les classes : une variable isolée ne peut pas etre affectée avec cet opérateur

Effectivement, c´est bien ce que j´avais crus lire.

Et effectivement, dslé pour l´erreur.
2^8-1 = 255 octes, c´est mieux pour un char

Une matrice de taille (n,p) c´est la représentation d´une application linéaire d´un espace vectoriel E de dimension de dimension n dans un espace vectoriel F de dimension p relativement à des bases de E et de F. Tu peux remplacer E par R^n et F par R^p et puisque tous les espaces vectoriels de même dimension finie sont isomorphes.
C´est pas bandant, les maths ?

Enfin, tout ça pour dire qu´une matrice, c´est un petit peu plus qu´un tableau 2D. C´est en particulier un moyen simple et pratique de modéliser des transformations géométriques (linéaires) de notre espace 3D (rotations, homothéties, ...). De plus toutes les opérations simples sur ces transformations géométriques (composition, inversion, ...) peuvent se calculer de manière explicite grâce aux matrices. Ca vaut le coup de s´y mettre.
Ceux qui ont encore plus de courage se mettront à la géométrie projective pour modéliser les applications affines (et non simplement linéaires). Les matrices marchent encore. Cool !