Cours programmation

Ce billet est à l’origine les notes que j’ai prises lorsque j’étais étudiant à l’école 42, il contient surtout les notions à connaitre pour la Piscine, il manque tout le reste du programme.

Quelques conseils pour eviter les 0

N’envoyez que vos fonctions, il ne faut pas qu’il y ai de fonction main sauf si un programme complet vous est demandé. Une fonction main vous servira uniquement a tester vos programmes. Vous pouvez telecharger code::block pour coder et faire vos tests.

Ne jamais utiliser de for ou ça vous coûtera un -42 ! Utilisez un while à la place. Pareil pour printf utilisez write.

Vos variables commencent par une minuscule sauf pour les nom séparés: myVariable, « myLibrary ». Et les structure MyStructure. Les noms des variables et commentaires sont à écrire en anglais sans le double slash, avec les slash multiligne /* */

Utilisez git ls-files pour verifier que vous avez bien push, n’envoyez uniquement que les fichiers demandés (pas de fichiers temporaires et cachés).

Verifiez les espaces et tabulations, la commande Vim gg=G vous permettra d’indenter automatiquement et Ctrl + s puis espace sur Emacs pour afficher les espaces et tabulations.

Tabulations et espace

Une tabulation à la place d’un espace ou inversement vous coutera un 0. Voici donc la liste des tabulations: int[tab]fonction() ou int[tab]myVariable

if[space](), while[space]()

Methodes de travail

_pour les gros projets, vous pouvez realiser un schema sur papier, indiquer le comportement du programme, ce qu’il fera avec votre variable, etc.

Terminal (zsh)

Note: les tirets – suivit d’une option sont à ajouter après la commande. Vous pouvez en combiner plusieurs exemples ls -la (lister les fichiers + détails et droits + fichiers cachés).

Aide et raccourcis

man

man pour manual permet d’obtenir de l’aide sur une commande ainsi que ses options ex : (q pour quitter)

flèche du haut

taper une ancienne commande, flèche du bas taper une commande plus récente après avoir fait flèche du haut.

tabulation

autocompletion, utile pour éviter de taper un long nom de fichier ou dossier.

Ctrl + c

SIGKILL le processus (souvent après boucle infinie)

ldapsearch 'uid' = (login) | grep mobile-phone

retrouve les informations d’un élève à partir du login

ldapsearch mobile=(number) | grep uid:

retrouver le login d’une personne d’après son numéro de téléphone.

ifconfig

donne des informations sur le réseau

sh fichier.sh

permet d’executer un fichier .sh contenant des scripts bash

Déplacements et affichage

pwd

affiche le dossier dans lequel on est (Print Working Directory)

ls

lister les fichiers -l (lettre L minuscule) détails et droits -a fichiers cachés

cd

changer de dossier, par défaut le lien est relatif ex: cd Rendu .. dossier parent cd seul retourne au home (~)

cat

affiche le contenu d’un fichier, à utiliser pour les textes ASCII, du code, un makefile etc… -e détails sur les espaces, etc

Manipulation des fichiers

mv

déplacer un fichier ex: monFichier mondossier/ renommer un fichier ex: monFichier fichierRenommé

cp

copier un fichier ex: cp monFichier fichierCopie -R copier un dossier ex: monDossier1 monDossier2

mkdir

créér un fichier ex: créer un dossier ex: mkdir monDossier

rm

supprime le fichier -r supprime le dossier + contenu -f force la suppression

ln

créé un lien -s symbolique le plus utilisé comme sur Windows ex: ln fichier1 fichier2

chmod

gestion des droits visible avec ls -l constitué de d rwx rwx rwx (dossier utilisateur groupe autres) r(valeur 4): read w(2): write/supprimer x(1): executer il faut additionner les valeurs pour donner les 3 droits possible chmod 777 monFichier.txt donne tout les droits à tout le monde

http://ft-clusters.com/peerworking/wiki/index.php/Emacs

Commandes Vim

Vim en tapant le nom depuis le shell le programme se lancera ou Vim monFichier.c pour créer en même temps

Note: il y a 3 modes, le mode intéractif permet d’utiliser des raccourcies comme le copier/coller mais c’est le point central pour accéder aux deux autres modes qui sont “Insertion” pour taper du texte et “Commande” pour enregistrer, quitter, etc.

Mode intéractif avec le raccourcie Echap

  • puis mode insertion avec raccourcie I, le mode insertion se lance si la touche n’est pas un raccourcie
  • ou le raccourcie : pour entrer en mode commandes
:w

enregistrer

:q

quitter

:x

enregistrer puis quitter

fn + F1

ajoute le header

dd

couper la ligne courante

'n'dd

couper ‘n’ lignes, ‘n’ etant un nombres bien entendu (idem pour copier ‘n’ lignes avec yy)

dw

pour effacer du curseur jusqua la fin du mot

gg=G

indentation auto, se fait en mode interactif avec Echap, quand vous ecrirez vous ne verrez rien c’est normal

p

coller (sous la ligne en cours)

yy

copier la ligne courante

y

copier la sélection.

o

passer en mode insertion en inserant un ligne en dessous

O

passer en mode insertion en inserant une ligne au dessus

i

passer en mode insertion

a

passer en mode insertion sur le caractere suivant

A

passer en mode insertion en fin de ligne

G

aller a la fin du fichier

gg

aller au debut du fichier

1G

pour allez au numero ligne entre

0

aller en debut de ligne

$

aller en fin de ligne

^

pour allez sur le premier charactere en debut ligne

r

pour remplacer

k

pour se deplacer vers le haut

j

pour se deplacer vers le bas

h

pour se deplacer vers la gauche

l

pour se deplacer vers la droite

:vsp

pour split verticalement

:sp

pour split horizontalement

%s/ancien_mot/nouveau_mot/g

pour remplacer toutes l’occurence des ancien_mot par les nouveau_mot sur tout le texte

Raccourcies Emacs

Ctrl + c -> Ctrl + h

créér le header

Ctrl + x -> Ctrl + s

sauvegarder mettre en fond

Ctrl + s puis espace

affiche les espaces et tabulations très pratique pour respecter la norme

Ctrl + s puis tab

voir les tabulations

Ctrl + -

undo (trait d’union et non underscore)

Esc + x et taper linum

voir les numéros de lignes

Les types de fichiers

.sh

contient des scripts Unix

.c

fichier source en langage C

.cpp

fichier source en C++

.h

fichier contenant les prototypes (voir plus bas leur role)

.o

fichier objet compilé à partir d’un .c, permet de gagner du temps à la compilation et de générer des .a

.a

c’est un librairie contenant souvent plusieurs fonctions. Voir comment compiler une librairie avec GCC.

Git

Vous devez créer un dossier Rendu sur votre home contenant des sous dossier nommé jxx (xx correspond au numéro du jour).

Créer un dépot git ou récupérer un dépot pour une correction

git clone adresse nomDuDossier

Chaque jour a une adresse différente, vérifiez que ça correspondent bien. La commande permet aussi de récupérer un dépot pour la correction

Mettre les fichiers et dossiers dans le dépot créé

git add nomFichier

spécifie le fichier à envoyer

git add nomDossier

vous pouvez avec cette commande envoyer tout un dossier, faites attention à avoir supprimé les fichiers temporaires (taper ls -a pour afficher les fichiers cachés).

git commit -m "message de la mise à jour"

prépare la mise à jour avec le nom du changelog (description de la modification)

git push origin master

permet de push, c’est à dire envoyer les fichiers sur le serveur. De cette manière vous serez corrigé. « origin master » se tape au tout premier push.

Voir contenu d’un dépôt et supprimer un fichier/dossier

git ls-files

permet de voir le contenu du dépot git rm nomFichier

git rm -r nomDossier

(-r pour suppression récursive, ajouter -f pour forcer si ça ne fonctionne pas)

puis confirmer:

git commit -m "suppression de nomFichier"

Le petit plus

git gui

Vous permet de lancer un GUI permettant de gérer vos fichiers a envoyer/commit/push tres facilement se ferme avec ctrl + c ou q

tig

Permet de voir un récapitulatif de vos derniers commits (n’est pas installé de base, utiliser le package manager d’osx, Homebrew pour l’installer)

git ls-tree --full-tree -r HEAD

Permet de voir les fichiers envoyés au serveur.

Installation et mise à jour de packages avec Homebrew

Homebrew est l’un des packages manager d’osx disponible en libre téléchargement sur le net, vous en aurez besoin si vous souhaitez installer de nouveaux paquets dans votre terminal (tig par exemple). Homebrew est regulièrement mis à jour il faut donc penser à le mettre à jour.

Vous ne pourrez pas tout installer ! Certains packages par exemple nécessitent les droits root à l’installation/utilisation.

brew update

Effectue une mise à jour des upgrades disponibles, ainsi que des paquets ajoutés ou supprimés (à effectuer avant d’installer quoi que ce soit)

brew upgrade

Met à jours les paquets outdated

brew doctor

Liste les problèmes de fonctionnement (ex : paquet installé introuvable) à résoudre manuellement

brew install

Installe la formula spécifiée (ex : brew install tig)

Compilation avec GCC

Compilation basique

gcc nomFichier1.c nomFichier2.c -o nomExecutable ou gcc -o nomExecutable nomFichier1.c nomFichier2.c

Exécution

./nomFichier

Execute le fichier appele « nomFichier »

-o

créé l’executable de sortie (mot écrit après l’option) //attention à ne pas confondre -o ne créé pas de .o !

-c

permet de générer un .o (mot écrit après l’option)

-L

permet de spécifier où est la libraire

.

dans le répertoire courant, vous pouvez donc utiliser -L.

-lstr

inclu la librairie libSTR à la compilation

-lft

inclu la librairie libft à la compilation

ranlib myLibrary.a (ou alors archivez avec l'option -s) ar -rcs

indexe les fonctions de la librairie et optimise le temps de compilation

Les flags

-W

affiche des avertissements sur des choses pouvant être améliorer

-Wall

affiche d’avantages d’avertissements

-Werror

chaque avertissement devient une erreur (pris en compte par la moulinette)

-Wextra

affiche des warning supplémentaire

-g

génère des information de debuguage permettant d’utiliser gdb avec l’executable créé.

-O0 / -O1 / -O2 / -O3

définie le niveau d’optimisation, (0 = aucune, 2 = defaut, 3 = max).

Création d’une librairie

gcc -c ft_putchar.c

creation du .o, les librairies se génère qu’à partir d’eux

ar rc ft_putchar.a ft_putchar.o

création de la librairie .a à partir du .o

gcc test.c ft_putchar.a -o test

création de l’executable test à partir d’un fichier .c et de la librairie créé (pas d’include nécessaire)

Les Makefiles

Les MakeFiles automatisent la compilation, plutôt que de réécrire gcc suivi des 50 fichiers à compiler, de flags et autres options une simple commande permettra de compiler tout le contenu du MakeFile.

Pour compiler le Makefile taper make. Le makefile ne compile que si les tabulations sont respectées ! Ajoutez un backslash \ pour indiquer une nouvelle ligne.

.PHONY: clean, all, re, fclean
NAME = nomDeVotreLibrairie.a
CFLAGS = -Wall -Wextra -Werror #vos flags de compilation
SOURCES = main.c ft_putchar.c \
          ft_putstr.c ft_strlen.c \
          ft_strstr.c ft_strdup.c

OBJS = $(SOURCES:.c=.o) 

all: $(NAME) 

$(NAME):
        gcc $(CFLAGS) -c $(SOURCES) -I. ar rc $(NAME) $(OBJS) ranlib $(NAME)
clean:
        rm -f $(OBJS) nomDeVotreLibrairie.h.gch
fclean: clean 
        rm -f $(NAME)
re: fclean all

C

Formatage et norme

/* commentaire multi ligne */
// commentaire monoligne C99 interdit !
#include <systemLibrary.h>

importer une librairie système fourni avec le langage (biblothèque)

#include “myLibrary.h”

importer sa librairie

{ }

contenu d’une fonction

( )

paramètres

NORME: les commentaire en double slash C99 // sont interdit. En rouge sont représenté les tabulations (Ctrl + s puis tab pour vérifier les tabulations sous Emacs). Il faut une tabulation après le type d'une fonction et variable et sauter une ligne pour les variables.

#include <librarie.htype fonction (paramètres) { type variable1; /*comment in english*/ type variable 2; /*Toujours sauter une ligne après la déclaration d’une variable sinon 0 !*/ variable 1 = 5; variable 2 = 0; if (variable1 > variable2) { contenu; } return (0); }

Libraries

#include <unistd.h>

(activé par défaut dans le terminal permet de manipuler des commandes comme write). On utilise < > pour les headers système, qui fonctionnent avec le C.

stdlib.h et stdio.h

permet de commandes basiques tel que le printf pour afficher du texte, le scanf pour récupérer une saisie

#include “myLibrairy.h”

inclu sa propre libraire, mettre des guillemets. Pour la créer voir la compilation avec GCC.

Un define avec une Macro

define ECRIRE_QUARANTE_DEUX() printf(“42”); /*c'est une macro car il y a des parenthèses et une commande qui s'execute */
int main () {
ECRIRE_QUARANTE_DEUX();
}

Les types de variables

NORME: après chaque type mettre une tabulation y compris dans les noms des fonctions ! Les octets vous permettront de mieux comprendre l'allocation dynamique (voir plus bas).

void (4 octets) à utiliser souvent dans une fonction quand celle-ci ne renvoit pas de résultat ou utilse des pointeurs int et long (4 octets) pour un nombre entié double et float (8 octets)pour un nombre décimal, float mieux géré par la carte graphique.

char pour une lettre, ne gère pas les accents et respecte la casse. La valeur doit être en apostrophes ex: ‘a

La fonction write

write(sortie, “contenu”, bits);

sortie 1 équivalent à mettre stdout pour standard output, correspond à l’écran entre guillemet le contenu ensuite le nombre de bits ou plutot le nombre de lettres affichées

write(1, “abc”, 3);

La fonction printf

printf est généralement interdit attention !

%d

affiche nombre entié ou valeur ASCII de la lettre

%f

affiche le contenu d’un décimal (float et double)

%c

affiche caractère

%ld

affiche un long (nombre plus grand que int)

%ud

affiche un unsigned int (entier positif).

%o

affiche un entier en octal (base 8).

%x

affiche un entier en hexadecimal (base 16).

%s

affiche une chaine de caractère

%zu

affiche un size_t (et ouééé plus besoin de cast en entier)

%p

Affiche l’adresse d’un pointeur

Lire et créer une chaine de charactères

Une chaine de charactère est un tableau permettant de former mots et phrases. Le tableau commence par la case 0 et il faut toujours compter une case supplémentaire pour la case du tableau qui se termine par \0. char chaine [5];

0 1 2 3 4 5
s a l u t \0
char chaine[] = "salut"; 
int i = 0;

while (chaine[i] != '\0')
{
printf("%c", chaine[i]); 
i++;
}

While permet de repeter des instructions tant que la condition en parenthese est respecte.

Structures conditionnels

if (valeur comparaison valeur et/ou valeur comparaison valeur) { contenu; }

exemple d’une condition if (si). Quand la condition est respectée elle renvoie 1.

==

égal à

 !=

différent de

>=

supérieur ou égal à

&&

et

 ||

ou

Les listes chaînées

Théorie

[0]->[1]->[2]->[...]->NULL

Liste simplement chainée

NULL<-[0]-><-[1]-><-[2]->[...]->NULL

Liste doublement chainée

2]->[0]->[1]->[2
2]-><-[0]-><-[1]-><-[2

Variantes circulaires

Pratique

Définition, déclaration et affectation d’un pointeur

Un pointeur ne fonctionne que dans les accolades dans lequel il est créé. Pour l’utiliser en dehors il faut soit créer une variable qui copiera sa valeur puis utilisera un return pour copier la nouvelle valeur dans la variable d’origine, soit pointer sur son adresse pour la modifier directement (donc fonction de type void possible). Une pointeur dans une même fonction a peu d’intêrets.

int variable; 
int *pointeurSurVariable;
variable = 10;
pointeurSurVariable = &variable; //& pour adresse, on pointe vers l'adresse pour récupérer la valeur

Fonction qui pointe sur une variable d’une autre fonction

void fonctionPointeur (int *pointeurSurVariable) //pointeur qui reçoit l'adresse, fonction type void suffit
{
*pointeurSurVariable += 2; //toujours utiliser l'étoile
}

int main ()
{
int variable;

variable = 5;
fonctionPointeur (&variable);
}

Le déréférencement

BESOIN D’UN REDACTEUR

Lire et écrire dans des fichiers

int fd;

char buff[32];
fd = open("file_name", flags);

Le flag d’ouverture est O_RDONLY, celui d’écriture est O_WRONLY. Il est possible d’utiliser plusieurs flags en meme temps `avec la syntaxe suivante : FLAG_1 | FLAG_2 | FLAG_3 … (pour plus d’infos sur comment fonctionnes les flags : http://fr.openclassrooms.com/informatique/cours/les-flags-4).

read(fd, buff, 32);// lit 32 caracteres depuis fd et les stock dans buff.
close(fd);// Ferme le fichier.

La récursivité

Une fonction récursive est une fonction qui se rappel elle même. Elle peut se rappeler même si toutes les instructions n’ont pas été lu, ainsi arrivé à la fin de l’appel en boucle elle liera la suite. Voici l’exemple donné durant la Piscine:

int ft (int i)
{/*i n'est pas initialisé à 0 car sinon ça valeur revient à 0 à chaque rappel se qui produit une boucle infini, on reçoit 0 en paramètre*/
if (i < 5)
{
i++;
write (1, “D”, 1);
fn(i);/*lis le programme jusqu'à cette partie, une fois arrivé au bout lis seulement la suite, la valeur actuel de i est renvoyé */
write (1, “F”, 1);
return (0);
}
else
{
return (0);
}
}

int main ()
{
fn (0);
return (0);
}

L’allocation dynamique de mémoire

Fonction <stdlib.h> obligatoire pour utiliser malloc et free, malloc permet d’allouer de la mémoire, free libère ensuite de la mémoire quand la variable n’est plus utilisée.

L’allocation dynamique est utile lorsque l’on veut travailler avec des plages mémoires tel que des tableaux ou autre dont on ne connait pas la taille à la compilation (au moment où on écrit le code). La taille du tableau est déterminée par une variable mais il est interdit d’écrire int tableau [taille]; car les compilateurs ne comprennent pas toujours ce code (seulement la version gcc c99). Il est extrèmement rare d’utiliser une simple variable (ou matrice) avec l’allocation dynamique. Le tableau peut s’écrire comme ceci sur une ligne (ne respecte pas la norme): int* memory= malloc(sizeof(int)*10) /* le 10 peut être remplacé par une variable qui peut prendre une valeur entrée par l’utilisateur */ En sachant que int vaut 4 octets on peut aussi écrire directement 4*10 ou même 40 le résultat: int* memory = malloc(40);

L’allocation dynamique selon la norme et vérification si ça marche dans un if:

int nbDeCases; 
int i; 
int* monTableauDynamique;

nbDeCases = 0; 
i = 0; 
monTableauDynamique = NULL;

scanf("%d", &nbDeCases);

if (nbDeCases > 0) 
{
monTableauDynamique = malloc(nbDeCases * sizeof(int)); 
if (monTableauDynamique == NULL) /*si le tableau est toujours égale à NULL c'est qu'il n'y a pas de cases..*/ 
{
exit(0); /*..donc le programme se quitte, l'allocation a échouée ou la valeur nbDeCases inférieur ou égal à 0*/
}

while (i < nbDeCases) {
}
printf("Valeur case numéro %d: ", i + 1); /*Valeur case 0 sera affiché au départ, pour comencer à 1 écrire i + 1 */ 
scanf("%d", &monTableauDynamique[i]); /*pour lire le contenu du tableau voir “Lire et créer une chaine de charactères” plus haut */
i++;
} 
free(monTableauDynamique);
}
return 0;

Passer un argument

int main (int argc, char **argv) /*argc nb d’arguments, argv[0] tableau de chaine de charactères*/ { if (argc == 2) /*si argc contient deux arguments, le premier étant le nom de l’executable à la case argv[0], l’argument est en argv[1]*/ { ft_putstr (argv[1]); } else { ft_putstr(“aucun argument entré”); } ft_putchar(“\n”); return (0); }

Il faut écrire l’argument après le nom de l’executable exemple: ./test argument1 Les espaces permettent de passer à l’argument suivant sauf si vous utilisez les guillemets: ./test “argu 1” “argu 2”

Le C++

Vector et Deques

Classes et constructeurs/destructeurs

#include <iostream>

using namespace std;

class Personnage {
public;

int health ()
{
}
};

int main()
{
return 0;
}

Polymorphisme

Web

HTML/CSS

<balise>contenu a l'interieur</balise>

Le slash indique la fermeture de la balise.

<!DOCTYPE html>
<html>
<head>
   <title>Titre de ma page visible sur la barre de navigation/onglet<?title>
</head>

<body>

Contenu de ma page

</body>

<?php
?>

</body>

</html>