Support de cours sur le langage D en PDF

Télécharger ce support de cours sur le langage D, formation sur les bases de langage D en pdf sur 5 pages.

D est un langage de programmation de systèmes et d’applications à usage général. C’est un langage de haut niveau, mais il conserve la capacité d’écrire du code haute performance et d’interagir directement avec les API du système d’exploitation et avec le matériel. D est bien adapté à l’écriture de millions de programmes de ligne à moyenne échelle avec des équipes de développeurs. D est facile à apprendre, fournit de nombreuses capacités pour aider le programmeur, et est bien adapté à la technologie agressive d’optimisation de compilateur.

D n’est pas un langage de script, ni un langage interprété. Il ne vient pas avec une VM, une religion, ou une philosophie dominante. C’est un langage pratique pour les programmeurs pratiques qui ont besoin de faire le travail rapidement, de manière fiable, et de laisser derrière eux un code facile à comprendre.

D est l’aboutissement de dizaines d’années d’expérience dans la mise en œuvre de compilateurs pour de nombreuses langues diverses, et la tentative de construire de grands projets utilisant ces langues. D s’inspire de ces autres langages (en particulier le C ++) et le tempère avec de l’expérience et de la praticité du monde réel.

Exemple de Hello World

En langage D, le programme Hello World va comme ceci:

importer std.stdio; // module d'E / S standard int main (arg [char] [] args) {writefln ('Hello World!'); revenir 0; }

writef est la version de type s de safeF de printf; writefln ajoute un caractère de nouvelle ligne à la fin. Le récupérateur de déchets D comprend un récupérateur automatique d’ordures, soulager le programmeur de la nécessité de gérer la mémoire explicitement. Cela permet aux programmeurs de se concentrer davantage sur la tâche à accomplir, par opposition à avoir à se soucier de l’état de chaque morceau de mémoire. En outre, il élimine toute une classe de bogues traitant des pointeurs pendants et références de mémoire invalides. Dans les périodes où le GC ralentirait l’application, il est toujours possible de l’éteindre complètement ou en utilisant C’s malloc et gratuit pour la gestion de la mémoire.

Modules

Dans D, les modules sont importés à l’aide de l’instruction import et ont une correspondance biunivoque avec les fichiers source, avec le point comme chemin séparateur. Chaque symbole dans un module a deux noms: le nom du symbole et le nom du symbole préfixé par le nom du module,
qui est appelé le nom qualifié complet ou FQN. Par exemple, writefln peut être appelé writefln ou std.stdio.writefln. Pour les cas où le
FQN est préféré, l’instruction d’importation statique importe les symboles du module mais évite de les placer dans l’espace de noms global. Par exemple,
Les modules std.string et std.regexp incluent des fonctions de recherche, de remplacement et de partage. Parce que je suis plus susceptible d’utiliser des fonctions de chaîne pure que std.regexp, je voudrais importer std.regexp statiquement, de sorte que chaque fois que je voulais utiliser l’une de ses fonctions, je devais être explicite, alors que je pourrais simplement appeler les fonctions de chaîne par leurs noms normaux.
Les modules peuvent avoir des constructeurs statiques et des destructeurs. La fonction this () statique dans tout module est le constructeur statique et est appelée avant principale(); après que le main a retourné le static, la fonction ~ this () est invoquée. Parce que les modules sont importés symboliquement, cela signifie qu’il n’y a pas d’en-tête des dossiers. Tout est déclaré une seule et unique fois, éliminant le besoin de déclarer des fonctions à l’avance ou de déclarer des cours à deux endroits et  essayer de garder les deux déclarations cohérentes.

alias et typedef

En D, il existe une distinction entre un alias et un type. Un typedef introduit un type entièrement nouveau dans le système de vérification de type et
surcharge de fonction, qui sont discutés plus tard. Un alias est un remplacement simple pour un type, ou éventuellement un symbole:
alias int size_t; typedef int myint; // ne peut pas convertir implicitement en alias int
someReallyLongFunctionName func;

Profitez de ce manuel de formation en PDF pour comprendre mieux le Langage D et enrichir votre connaissance.

Commencez à télécharger ce cours adapté pour vous et à apprendre Langage D.

The D Programming Language http://0-delivery.acm.org.innopac.lib.ryerson.ca/10.1145/1240000/12…
3 of 58/27/2007 8:01 PM
The scope statement is designed to make for a more natural organization of code by allowing a scope’s cleanup, success and failure code to be
logically grouped:
void doSomething() { scope(exit) writefln(« We exited. »); scope(success) writefln(« We exited
normally. »); scope(failure) writefln(« We exited due to an exception. »); … }
Scope statements are executed in reverse order. Script syntax DMD, the reference D compiler, supports the -run option, which runs the program
taken from standard input. This allows you to have self-compiling D scripts, as long as the appropriate line is at the top, like so:
#!/usr/bin/dmd -run
Type Inference
D allows the automatic inferring of the optimal type of a variable with the auto-declaration:
auto i = 1; // int auto s = « hi »; // char[4] This allows the compiler to choose the optimal type when that functionality is needed.
foreach
Some of you might be familiar with the foreach construct; it essentially says, “do this to every element of this array”as opposed to “do this a set
number of times, which happens to be the length of the array”. foreach loops simplify iteration through arrays immensely, because the
programmer no longer even has to care about the counter variable. The compiler handles that along with making each element of the array
available:
char[] str = « abcdefghijklmnop »; foreach(char c; str) writefln(c);
You also can obtain the index of the element by declaring it in the loop:
int [] y = [5, 4, 3, 2, 1]; foreach(int i, int x; y) writefln(« number %d is %d », i,
x);
Finally, you can avoid worrying about the types of the variables, and instead use type inference:
foreach(i, c; str)
This opens up the field for numerous compiler optimizations that could be performed—all because the compiler is taking care of as much as
possible while still providing the programmer with the flexibility to accomplish any given task.
Exceptions
As a rule, D uses exceptions for error handling as opposed to error codes. D uses the try-catch-finally model for exceptions, which allows
cleanup code to be inserted conveniently in the finally block. For those cases when the finally block is insufficient, scope statements come in
quite handy.
Classes
Like any object-oriented language, D has the ability to create object classes. One major difference is the lack of a virtual keyword, unlike with
C++. This is handled automatically by the compiler. D uses a single-inheritance paradigm, relying on interfaces and mixins, which are discussed
later to fill in the gaps. Classes are passed by reference rather than by value, so the programmer doesn’t have to worry about treating it like a
pointer. Furthermore, there is no -> or :: operator; the . is used in all situations to access members of structs and classes. All classes derive from
Object, the root of the inheritance hierarchy:
class MyClass { int i; char[] str; void doSomething() { … }; }
Classes can have defined properties by having multiple functions with the same name:
class Person { private char[] PName; char[] name() {return PName;} void name(char[] str) { // do
whatever’s necessary to update any // other places where the name is stored PName = name; }
}
Classes can have constructors and destructors, namely this and ~this:
class MyClass { this() { writefln(« Constructor called »);} this(int i) { writefln(« Constructor
called with %d », i); } ~this() { writefln(« Goodbye »);}
Classes have access to the constructors of their base class:
this(int i) { super(1, 32, i); // super is the name of the // base class constructor