D Documentation
in
[ Log in ]
[ Home ][ Up ]
  1. Introduction
    1. A simple tutorial
    2. Switching to D
    3. An advanced tutorial
  2. Language Reference
    1. General syntax
    2. Statements
      1. Expression Statements
      2. If statement
      3. While statement
      4. Switch-Statement
      5. Do-While Statement
      6. For statement
      7. Foreach Statement
      8. Try statement
      9. Throw statement
    3. Types
    4. Error Handling
    5. Memory Management
  3. Std. runtime library (Phobos)
    1. std.base64
    2. std.boxer
    3. std.compiler
    4. std.conv
    5. std.ctype
    6. std.date
    7. std.file
    8. std.format
    9. std.gc
    10. std.intrinsic
    11. std.math
    12. std.md5
    13. std.mmfile
    14. std.outbuffer
    15. std.path
    16. std.process
    17. std.random
    18. std.recls
    19. std.regexp
    20. std.socket
    21. std.socketstream
    22. std.stdint
    23. std.stdio
    24. std.stream
    25. std.string
    26. std.system
    27. std.thread
    28. std.uri
    29. std.utf
    30. std.zip
    31. std.zlib
  4. Tango
    1. Introduction
    2. Tutorials
    3. API Reference
  5. Libraries and Tools
    1. mango
    2. Build
  6. Related Links
  7. About this documentation
    1. The docwiki software
    2. TTT
    3. Docwiki reference
    4. Style guide
    5. FAQ
    6. To do
Expression Statements
An expression statement consists just of any expression. Basically, expressions are:
  • Function calls ("foo()")
  • Assignments ("=", "+=", ...), see operators
  • Comparations ("==", "<", "is", ...), see operators
  • "Mathematical", boolean and unary expressions ("a + b", "a - b", "a && b" ...), see operators
  • Conditional expressions ("foo ? "a" : "b")
  • Literal values (like 8 or the string "abc"), see literal values
  • Variables, see variable types
  • Some special keywords ("this" or "super()")

Examples:
x = y;
foo();
a = (b < c) ? b : c;


Special cases:
There are some expression statements that need some more explanation about what they do and - that`s the point - in which order they do this.

Examples:
i = 1;
++i;    /* prefix increament */
i++;    /* postfix increament */
i += ++i;    /* error: value of i undetermined */
i += i++;    /* error: value of i undetermined */

What`s the difference between those two statements?
    Well, it is just the same thing in C/C++. The side effect of both increament-s is increament i by 1, i.e., i = i + 1. However, the value of the prefix increament expression is the result of i+1, say in our example, 2. Whereas the value of the postfix expression is the old value of i, say, 1 in this case. Attention: those two expressions followed by the comment /* error: value of i undetermined */ are bad. "Unless otherwise specified, the implementation is free to evaluate the components of an expression in any order. It is an error to depend on order of evaluation when it is not specified. " It is because of something like "sequence point" in C/C++. Those two expressions try to change the value of the same variable i twice between two sequence points. If you do not know what is a "sequence point". You`d better read the C/C++ standard report or any books on C/C++ talking about the term, or easier, google it. 

while ( (++i) < j )
  statement;

while ( (i++) < j )
  statement;


As before explained, there is a big difference between pre-incrementals and post-incrementals inside the condition of a while-loop.
  • First example increments i before the comparison,
  • second one increments i after the comparison.
With the first example you can avoid using while-statements like:
while( i < j )
  i++;


Special Keywords

See also:
Classes

  • "this" is a pointer to current object (pointer gets dereferenced in statements afaik - so x = this; would copy the object) and the 'name' for constructors.
    class foo
{
  this() { /* ... */ }

  foo bar() { return this; }
}

  • "super()" calls the constructor of the base-class:
    class Foo
{
  this() { /* ... */ }

  /* ... */
}

class Bar : Foo
{
  this() { super(); }   // calls Foo.this()
}


Conditional expressions
Conditional expressions are expressions that are evaluated on boolean purpose; whether something is true or false for example. They're used mostly in control structures, such as while loops or if constructs. For conditional expressions there exist special operators, like AND (&&) and OR (||).

if(conditional expression)
{
  // code to execute
}


You are not limited to only using conditional operators in conditional expressions; in fact, sometimes it's useful to use a normal operator in a conditional expression. What is true though, is that for a true conditional expression, the eventually evaluated value will be 1 (true) or 0 (false). Any other value than 0 will be interpreted as being true.

== Equals, != Not equals
1 == 2; // evaluates into FALSE (0)
1 == 1; // evaluates into TRUE
1 != 2; // evaluates into TRUE


&& And, || Or
(1 == 1) && (2 == 2); // evaluates into TRUE
(1 == 1) && (1 == 2); // evaluates into FALSE
(1 == 1) || (1 == 2); // evaluates into TRUE
(1 == 2) || (3 == 4); // evaluates into FALSE


To do: Explain conditional expressions and special keywords here, maybe a bit of expression evaluation and special cases (i += ++i;) too.
PHP docwiki written by Markus Dangl. Best viewed with Mozilla Firefox.
This is the inofficial wiki for documenting the D programming language.
- Profiler -
Time for site generation: 0.0541 s