Discussion :

[Niark13]

Bonjour,

je voulais juste faire un post afin de lister des petits détails dans la grammaire de D qui font de ce langage un vrai bonheur à utiliser.
On parle souvent de ses avantages par rapport à C++ pour vanter ses mérites : Garbage collector, scope(), contrats, ... mais on oublie souvent que la grammaire a été améliorée.

Hier soir, je suis tombé sur une erreur de compilation qui m'a littéralement arraché un sourire (oui, c'est plutôt rare). C'est arrivé avec le code suivant :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
if (success);
{
    // instructions...
}

Oui c'est idiot comme erreur de mettre un ';' après un if, mais la journée avait été longue. Et que celui à qui ça n'est jamais arrivé me jette la première pierre !

Eh bien j'ai eu la surprise de voir le compilateur (gdc) me dire

No ';' allowed for empty if statements. Use {} for empty if statements.

Voilà quelques minutes de débogage de gagnées !

De la même manière le code suivant

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int* a, b;

Correspond à la déclaration d'un pointeur et d'un entier en C. Alors qu'en D, il correspond à la déclaration de deux pointeurs. Ces deux pointeurs sont d'ailleurs initialisés à null.

Ce genre de petits détails ne bouleverse pas le monde de la programmation, mais mis bout à bout, ils en font un langage plus résistant aux erreurs, plus logique et plus agréable à utiliser.

N'hésitez pas à compléter cette liste dans vos réponses.

[Invité]

C'est vrai que la syntaxe est très agréable.

J'aime beaucoup l'addition récente de l'arithmétique des tableaux qui permettent de travailler un peu comme dans matlab.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a[] = b[] + c[] * 2; // évite une boucle for

Sinon les templates/mixins permettent de faire tout ce que fait le préprocesseur, en plus propre car cela à lieu après l'analyse lexicale.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
template Singleton()
{
	public static final typeof(this) instance ()
	{
		if (_instance is null )
		{
			synchronized
			{
				_instance = new typeof(this)();
			}
		}
		return _instance;
	}
	private static T _instance = null;
}
 
class ASingletonClass
{
	mixin Singleton;
 
	public char[] message = "Hello world !\n";
}
 
writefln(ASingletonClass.instance.message); // on a un singleton

Enfin, ca n'à l'air de rien mais ca sert quand on fait du calcul de précision, c'est agréable. Les constantes flottantes sont calculées avec la précision real (10 octets).

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
const PI = 4.f * atan(1.f);
const TEN_PI = 10.f * PI; // pas de perte de précision par rapports à des constantes rentrées à la main

[TSalm]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

a[] = b[] + c[] * 2; // évite une boucle for

J'ai essayé avec la version 2.
Mais je ne comprends pas bien comment ça fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import
    std.stdio
    ;
 
void main(char[][] args)
{
    uint[] a = [10,12,13] ;
    uint[] b = [1,2,3] ;
 
    uint[] c ;
    c[] = a[] + b[]*2 ;
 
    foreach (  e ; c )
    {
        writeln(e);
    }
}

c[] est vide !?

[Invité]

Si c est un tableau dynamique, il est par défaut un tableau vide.
La ligne ne va rien faire car la tranche de tableau c[] est vide. Apparemment l'arithmétique des tableaux est faite pour simplifier l'écriture des calculs mais pas pour faire des allocations.

Tu peux faire marcher ton exemple soit en utilisant un tableau statique

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

uint[3] c ;

soit en allouant la place suffisante pour le resultat :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

c.length = a.length;

ou encore :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
c = a.dup; // c est le tableau dynamique (= couple pointeur + taille)
c[] += 2 * b[]; // c[] est une tranche de tableau

D'ailleurs, ca marche aussi dans DMD 1.xxx

EDIT : en fait, c'est pas encore bien documenté comme feature.

[TSalm]

Je ne connaissais pas. Très utile effectivement !

[Niark13]

Je complète un peu le post avec la CTFE (Compile Time Function Execution) qui, comme son nom l'indique, permet au compilateur de remplacer un appel de fonction par son résultat si celui-ci est directement calculable à la compilation.

http://www.digitalmars.com/d/2.0/fun...interpretation

De quoi éviter pas mal de maux de tête en évitant la métaprogrammation à base de templates.

[Invité]

La CTFE sera également dans C++0x avec le mot-clef constexpr... le jour où ca sera implémenté.
Alors qu'en D on peut en profiter maintenant.