## Un peu de troll !
```d
// 12 lignes de beau code D
Vect3D!T opBinary(string op, O)(in O other){
static if(__traits(isArithmetic, O))
return Vect3D!T(
mixin("x"~op~"other"),
mixin("y"~op~"other"),
mixin("z"~op~"other"));
else static if(is(O : Vect3D!T)
return Vect3D!T(
mixin("x"~op~"other.x"),
mixin("y"~op~"other.y"),
mixin("z"~op~"other.z"));
}
```
Surcharge tous les opérateurs binaires (+, -, *, /)
Vect3D op Vect3D ainsi que Vect3D op nombre
## La même chose en C++
```cpp
// Beurk!
Vect3D<T> operator+(const Vect3D<T>& other){
return Vect3D<T>(
x+other.x,
y+other.y,
z+other.z);
}
Vect3D<T> operator-(const Vect3D<T>& other){
return Vect3D<T>(
x-other.x,
y-other.y,
z-other.z);
}
Vect3D<T> operator*(const Vect3D<T>& other){
return Vect3D<T>(
x*other.x,
y*other.y,
z*other.z);
}
Vect3D<T> operator/(const Vect3D<T>& other){
return Vect3D<T>(
x/other.x,
y/other.y,
z/other.z);
}
Vect3D<T> operator+(const float& other){
return Vect3D<T>(
x+other,
y+other,
z+other);
}
Vect3D<T> operator-(const float& other){
return Vect3D<T>(
x-other,
y-other,
z-other);
}
Vect3D<T> operator*(const float& other){
return Vect3D<T>(
x*other,
y*other,
z*other);
}
Vect3D<T> operator/(const float& other){
return Vect3D<T>(
x/other,
y/other,
z/other);
}
```
Notez la scrollbar !
- 24 lignes de code C++, 24 en plus par type arithmétique
- Pour gérer tous les types arithmétiques (sans conv implicite)
- +300 lignes
## Pour faire court...
- Ca ressemble à du Java
- Générique / polyvalente
- Pas trop verbeuse (il y a mieux)
- Méchament puissante
# Passons aux choses sérieuses !
## Hello world!
```d
import std.stdio;
void main(){
writeln("Hello, World!");
}
```
###### Console
```bash
% dmd main.d
% ./main
Hello, World !
```
## Hello you !
```d
import std.stdio;
void main(){
string name = "students";
writeln("Hello ",name,"!");
}
```
Ca vous rapelle de bons souvenirs?
###### Console
```bash
% dmd main.d
% ./main
Hello students!
```
Types de variables
dlang.org/type.html
|---Nom---|--Init--|-Bits-|-------Type-------|
|:---|:----:|:----:|:----|
|void|?|8|Sans type|
|**bool**|false|1/8|Booléen|
|byte|0|8|Entier signé|
|ubyte|0|8|Entier positif/nul|
|short|0|16|Entier signé|
|ushort|0|16|Entier positif/nul|
|**int**|0|32|Entier signé|
|long|0|64|Entier signé|
|**float**|nan|32|Flotant|
|**double**|nan|64|Flotant|
|real|nan|max|Flotant|
|cfloat|nan|64|Flotant complexe|
|char|0xFF|8|Caractère|
|**string**|""|?|Chaîne de caractères|
Propriétés des types
dlang.org/property.html
|---Nom---|-------Utilité-------|
|:---|:----|
|.min|Valeur Min|
|.max|Valeur Max|
|.init|Valeur d'initialisation|
|.stringof|Nom|
|---|---|
|.epsilon|Plus petite valeur possible|
|.dig|Nombre max de décimales|
|.re|Partie réelle|
|.im|Partie imaginaire|
|---|---|
|.classinfo|[Informations sur le type de la variable](http://dlang.org/phobos/object.html#TypeInfo_Class)|
## Tableaux & foreach
```d
import std.stdio;
void main(){
string names[] = ["Bryan", "Brendan", "Florentin"];
foreach(name ; names){
writeln("Hello ",name,"!");
}
}
```
###### Console
```bash
% dmd main.d
% ./main
Hello Bryan!
Hello Brendan!
Hello Florentin!
```
## Tableaux
C++
```cpp
auto var1 = "12" + 5 + 2;//var1 = ?
auto var2 = "12" + 5 + '2';//var2 = ?
int tab[5] = {0,1,2,3,4};
auto var3 = tab + 6;//var3 = ?
```
- var1: Pointeur sur char, dans une case mémoire interdite
- var2: Pointeur sur char, vaut ')��� '
- var3: Pointeur sur int dans une case mémoire interdite
D
```d
auto var1 = "12" + 5 + 2;//Compilation error
//incompatible types for (("12") + (5)): 'string' and 'int'
auto var2 = "12" ~ 5 ~ 2;// OK : Concaténation de string~char~char
int tab[] = [0,1,2,3,4];
auto var3 = tab + 6;//Compilation error
//incompatible types for ((tab) + (6)): 'int[]' and 'int'
auto var4 = tab[] ~ 6;//OK : Ajoute 6 à la fin du tableau
```
## Classes
```d
class Foo : ClassA, IfaceA, IfaceB{
public:
this(){super();}//Ctor
~this(){}//Dtor
void function(){}
string member;
}
auto f = new Foo();
```
- Chaque spécificateur peut être écrit de plusieurs façons suivant sa portée:
```d
private property void function();//Unique (java)
private{ property{ void function(); } }//Accolades
private property: void function();//Jusqu'au prochain (C++)
```
- et peuvent être mixés a volonté
```d
private:
property{
void function();
}
```
## Spécificateurs
[http://dlang.org/attribute.html](http://dlang.org/attribute.html)
|---Nom---|-------Utilité-------|
|:---|:----|
|public|Visibilité totale|
|private|Visibilité dans la classe|
|protected|Visibilité dans la classe et les filles|
|package|Visibilité dans le package D|
|abstract|Réécriture obligatoire, pas d'instance|
|override|Ecrase la fonction mère|
|synchronized|Un seul accès à la fois (multiphreading)|
|static|Accessible sans instance de classe|
|__gshared|Partagé entre tous les threads|
|@safe/trusted/system|Suivant si des segfaults sont envisageable|
|@nothrow|Suivant si des segfaults sont envisageable|
|@pure|Ne dépends que de ses args (Maths)|
|@creez_le_votre|[Regarder ici](http://dlang.org/attribute.html#UserDefinedAttribute)|
## Universal Function Call Syntax (UFCS)
Peut paraître sale au premier abord, mais super pratique !
```d
function(arg0, arg1);
arg0.function(arg1);//même chose
function2(arg0);
arg0.function2();//même chose
arg0.function2;//même chose
```
Permet d'éviter les "friend" quand ont veut étendre des fonctionnalités déja implémentées:
```d
string randomizeCase(in string s){...}
someString.randomizeCase();
```
Permet d'enchaîner plein de trucs:
```d
"Hello Gay World".strip.randomizeCase.rainbowString.center(80,"~")
```
## UFCS - @property
C++
```cpp
class Yolo{//Solution 1, verbeuse
public:
GetName(){return m_name;}
SetName(string name){m_name = name;}
private:
string m_name;
};
yoloInstance.GetName();
yoloInstance.SetName("toto");
class Yolo{//Solution 2, pose des limites
public:
string name;
};
yoloInstance.name;
yoloInstance.name = "toto";
```
```cpp
//Problème
class Yolo{
public:
string name;
int GetAge(){return aujourdhui - m_datenaissance;}
private:
//...
};
//deux getters, deux syntaxes différentes
yoloInstance.name;
yoloInstance.GetAge();
```
## UFCS - @property
D
```d
class Yolo{
public:
string name;
@property int age(){return aujourdhui - m_datenaissance;}
private:
//...
}
//Même syntaxe
yoloInstance.name;
yoloInstance.age;
```
## Encapsulation
En D, on peut encapsuler n'importe qui n'importe où !
```d
class A{
import std.stdio;
void fun(){
import std.stream;
class Handy{
struct yolo{
//...
}
}
void wtf(int arf){
//...
}
}
}
```
# Templates
On verra ça mieux plus tard !
C++
```cpp
//something<sometemplate>
vector<int> var;
vector<vector<int> > var;
```
D
```d
//something!sometemplate;
to!string(12);
Tuple!(int, string)(42, "La réponse");
```