Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

C and bash obvious cheatsheet

By: a guest on Apr 25th, 2012  |  syntax: C  |  size: 7.82 KB  |  hits: 21  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
This paste has a previous version, view the difference. Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. --------------------------------------------------------------- BASH ------------------------------------------------------------------
  2.  
  3. toujours " #!/bin/sh " en début de document!
  4.  
  5. "variable:"
  6. - pas d espace entre le signe ' = '
  7.   exemple: " va=1 "
  8.  
  9. - pas obliger d affecter des valeurs directement.
  10.   il est possible de faire " va= " et d utiliser " va " par la suite.
  11.  
  12. "les différents $":
  13.  $# = nombre d arguments
  14.  $? = statut de la dernière commande executée
  15.         exemple:
  16.         cp "$src"/"$j" "$dest"
  17.  
  18.         if [ ! $? -eq 0 ]; then
  19.                 print_verbose "Erreur: impossible de copier $src/$j dans $dest/${j}"
  20.         fi
  21. $0 = nom du script courant => nom du programme appelé si dans un programme
  22. $1 = premier argument; $2 = deuxième argument etc..
  23.  
  24. $@ = tous les arguments protégés en cas de blancs.
  25.         exemple:
  26.         for arg in "$@"; do
  27.                 ... # utilisation de "$arg"
  28.         done
  29.         donc si appelle d une fonction par exemple, on peut lire les argument avec $@. $* est similaire mais ne prend pas en compte les blancs.
  30.  
  31. - /!\ quand on utilise une valeur il faut mettre les doubles quotes "$… " comme "$nom" ou même on peut mettre "${nom}" comme ça
  32.           si jamais il y a des blancs dans le nom de la variable, c est correctement interprété.
  33.  
  34. "les boucles:"
  35.  
  36. - if:
  37.         structure:
  38.         if [ "$x" -eq 3 ]; then
  39.                 blablabla
  40.         elif [ -e "$lol" ]; then
  41.                 bloblo
  42.         fi
  43.  
  44.         les options:
  45.         -n chaine       la chaîne n’est pas vide
  46.         -z chaine       la chaîne est vide
  47.         chaine1 = chaine2 les deux chaînes sont égales
  48.         chaine1 != chaine2 les deux chaînes sont différentes
  49.         int1 -eq        int2 égalité
  50.         int1 -ne        int2 différents
  51.         int1 -ge        int2 ≥
  52.         int1 -gt        int2 >
  53.         int1 -le        int2 ≤
  54.         int1 -lt        int2 <
  55.         -e name         name existe
  56.         -d name         name est un répertoire
  57.         -f name         name est un fichier
  58.         -h name         name est un lien symbolique
  59.         -r name         name peut être lu
  60.         -w name         name peut être écrit
  61.         -x name         name peut être exécuté
  62.  
  63. - for:
  64.         structure:
  65.         for i in "$src"/*; do                                           */
  66.                 utiliser i avec "$i"
  67.         done
  68.  
  69. - while:
  70.         structure:
  71.         while [ $# -ne 0 ]; do
  72.                 arg="$1"
  73.                 shift
  74.                 ... # utilisation de "$arg"
  75.         done
  76.  
  77. - case:
  78.         structure + exemple:
  79.         case "$reponse" in
  80.         oui|Oui|OUI)
  81.                 echo "OK j'efface"
  82.                 rm "$choix"
  83.                 continuer=0
  84.         ;;
  85.         [Nn][Oo][Nn])
  86.                 echo "Bon, tant pis !"
  87.                 continuer=0
  88.         ;;
  89.         *) echo "pas compris" ;;
  90.         esac
  91.  
  92. voir cours02 pour plus de détails.
  93.  
  94. "faire une fonction: "
  95. - ma_fonction () {
  96.         blablabla
  97.   }
  98.  
  99. - tous script sh commence par: "#!/bin/sh" appelé le shebang, c est le nom de l interpréteur (il y en a d autre)
  100.  
  101. - quand on tape "exec ls" exec remplace le shell courant par la commande "ls".
  102.   Par défaut on a le process sh, si on fait "ls" le sh lance un autre sh dans lequel il lance ls, puis une fois les données
  103.   affichées il tue le sh qu il a créé. Quand on fait exec ls, ça remplace le shell courant par le shell dans lequel on lance sh.
  104.  
  105. - à la fin d un script on peut mettre "exit" pour quitter le shell. On peut aussi mettre "exit ?" ? étant un chiffre.
  106.   mais si on ne met rien le script se termine quand il n y a plus rien à exécuter.
  107.  
  108. - lire une variable au clavier: read ma_variable
  109.                                                                 echo "$ma_variable"
  110.  
  111.  
  112. ------------------------------------------------------------ C -------------------------------------------------------------------
  113.  
  114. difference entre "const char * "  et  " char * const "
  115. const char * : la chaine de caractères ne peut pas être modifiée mais le pointeur oui
  116. char * const : la chaine de caractères peut être modifiée mais pas le pointeur
  117.  
  118. - TOUJOURS tester si l allocation mémoire a réussie: malloc, calloc, realloc
  119.  
  120. "LES STRUCTURES & TYPEDEF":
  121. les typedef:
  122.  
  123. - pour bien faire un typedef on fait:
  124.  
  125.  
  126. les structure récursive:
  127. exemples:
  128.         - classique:
  129.  
  130.         struct struct {
  131.             int variable1;
  132.             char* autreVariable;
  133.             double nombreDecimal;
  134.         }NomDeVotreStructure;
  135.  
  136.  
  137.         - déclaration de la structure dans la structure:
  138.  
  139.         typedef struct _Element Element; // NE PAS OUBLIER LE _
  140.         typedef Element* MaStructure; <<<-----
  141.  
  142.         struct _Element {
  143.                 int variable1;
  144.                 char* variable2;
  145.                 MaStructure* amis; <<<<-----
  146.         };
  147.  
  148. - allouer les variables des structures:
  149.         si on a une fonction:
  150.         void initialiserCoordonnees(Coordonnees* point){
  151.         (*point).x = 0;
  152.         (*point).y = 0;
  153.         }
  154.  
  155.         ici point est une "pointeur" donc "point" est une adresse et donc on utilise *point pour acceder à l endroit pointé, ici c est une structure.
  156.         On veut accéder aux éléments de la structure pointée, donc on fait (*point).x ;
  157.         On peut aussi faire: point->x ;
  158.  
  159.         Si on ce n est pas un pointeur on accède simplement à la variable comme ceci:
  160.         point.x = ...;
  161.  
  162.         donc en gros:
  163.         int main(void){
  164.             Coordonnees monPoint;
  165.             Coordonnees *pointeur = &monPoint;
  166.  
  167.             monPoint.x = 10; // On travaille sur une variable, on utilise le "point"
  168.             pointeur->x = 10; // On travaille sur un pointeur, on utilise la flèche
  169.  
  170.             return 0;
  171.         }
  172.  
  173.  
  174. "LES LIBRAIRIES":
  175. #include <string.h> // pour tout ce qui est relatif aux strings
  176. #include <stdlib.h> // pour les malloc calloc et realloc
  177. #include <stdio.h>  // IO pour in and out donc pour les printf et scanf
  178.  
  179. "LES STRINGS":
  180. - char* strncpy(char* dest, char const* src, size_t n);
  181.   copie les n premiers caractères de src dans dest. Retourne dest.
  182.   Attention ! n’ajoute pas le '\0' à la fin si src contient plus de n caractères !
  183.  
  184. - char* strncat(char* dest, char const* src, size_t n);
  185.   ajoute au plus n caractères de src à la fin de dest. Retourne dest.
  186.  
  187. - int strcmp(char const* s1, char const* s2);
  188.   Compare {ordre alphabétique} les chaînes s1 et s2. Retourne un nombre négatif si s1 < s2, 0 si les deux chaînes sont identiques et un nombre positif si s1 > s2.
  189.  
  190. - int strncmp(char const* s1, char const* s2, size_t n);
  191.   comme strcmp, mais ne compare "au plus que les n premiers" caractères de chacune des chaînes.
  192.  
  193. - size_t strlen(char const * s);
  194.   Retourne le nombre de caractères dans s "sans le caractère nul de la fin \0".
  195.  
  196. - char* strchr(char const* s, char c);
  197.   Retourne un pointeur sur la première occurrence de c dans s, ou NULL si c n’est pas dans s.
  198.  
  199. - char* strrchr(char const* s, char c);
  200.   idem que strchar mais en partant de la fin. Retourne donc la dernière occurrence de c dans s.
  201.  
  202. - char* strstr(char const* s1, char const* s2);
  203.   retourne le pointeur vers la première occurrence de de s2 dans s1 (ou NULL si s2 n’est pas incluse dans s1.
  204.  
  205. - allocation dynamique de nom avec strlen(ma_string);
  206. - définir une TAILLE_MAX pour allouer des string, comme: char nom_fichier[TAILLE_MAX];
  207.   ou
  208.         char nom_fichier = NULL; nom_fichier = malloc(TAILLE_MAX+1 * sizeof(char)); if(NULL != nom_fichier){ ... };
  209.         si on ne peut pas donner la tailler qu aura la string au moment de sa création (exemple si on a une string dans un structure).
  210.   OU ALORS faire de l allocation dynamique, déclarer:
  211.         int variable_length = strlen(variable); char* ma_string = calloc(variable_length+1, sizeof(char)); if(NULL != ma_string){ ... };
  212. - Toujours mettre manuellement le caractère \0 en fin de string.
  213.  
  214. "LES POINTEURS":
  215.  
  216. - pour faire un swap:
  217. void echange(int* a, int* b){
  218.         int const copie = *a;
  219.         *a = *b; // a et b sont des pointeurs, donc des adresses. Donc pour avoir accès au contenu pointé il faut faire *a et *b
  220.         *b = copie;
  221. }
  222.  
  223. - pour une fonction qui demande ma_fonction(type* variable) il faut lui donner une adresse.
  224.         si on a type x = 0; on peut lui passer &x
  225.         si on a type* x; on peut lui passer x
  226. si on a un pointeur sur un structure et qu on a besoin d acceder à un élément on fait
  227.         &(la_stract->mon_objet)
  228.  
  229.  
  230. "quelques trucs à ne pas oublier..":
  231.  
  232. - VERIFIER si on ne pourrait pas mettre un unsigned
  233. - VERIFIER si une variable ne pourrait pas être const
  234. - faire des prototypes
  235. - toujours faire des vérifications pour les nombres voir si ils sont cohérents avec ce qu on veut (<0 ou >0 etc);
create a new version of this paste RAW Paste Data