Category: d Programming

D Programming – Useful Resources ”; Previous Next The following resources contain additional information on D Programming. Please use them to get more in-depth knowledge on this topic. Useful Video Courses 2D and 3D Animation with After Effects 14 Lectures 1 hours Harshit Srivastava More Detail WebGL 2D/3D Programming and Graphics Rendering For The Web 29 Lectures 4 hours Frahaan Hussain More Detail Create a 3D multi-player game using THREE.js and Socket.IO 35 Lectures 2.5 hours Nicholas Lever More Detail Java Courses in Tamil 188 Lectures 11.5 hours Programming Line More Detail 3D Modeling in Blender 2.8 for Unity Video Game Developers 59 Lectures 7 hours Billy McDaniel More Detail Création d”un tableau de bord de suivi d”activité avec Excel 18 Lectures 2 hours Marc Augier More Detail Print Page Previous Next Advertisements ”;

D Programming – Aliases ”; Previous Next Alias, as the name refers provides an alternate name for existing names. The syntax for alias is shown below. alias new_name = existing_name; The following is the older syntax, just in case you refer some older format examples. Its is strongly discouraged the use of this. alias existing_name new_name; There is also another syntax that is used with expression and it is given below in which we can directly use the alias name instead of the expression. alias expression alias_name ; As you may know, a typedef adds the ability to create new types. Alias can do the work of a typedef and even more. A simple example for using alias is shown below that uses the std.conv header which provides the type conversion ability. Live Demo import std.stdio; import std.conv:to; alias to!(string) toString; void main() { int a = 10; string s = “Test”~toString(a); writeln(s); } When the above code is compiled and executed, it produces the following result − Test10 In the above example instead of using to!string(a), we assigned it to alias name toString making it more convenient and simpler to understand. Alias for a Tuple Let us a look at another example where we can set alias name for a Tuple. Live Demo import std.stdio; import std.typetuple; alias TypeTuple!(int, long) TL; void method1(TL tl) { writeln(tl[0],”t”, tl[1] ); } void main() { method1(5, 6L); } When the above code is compiled and executed, it produces the following result − 5 6 In the above example, the type tuple is assigned to the alias variable and it simplifies the method definition and access of variables. This kind of access is even more useful when we try to reuse such type tuples. Alias for Data Types Many times, we may define common data types that needs to be used across the application. When multiple programmers code an application, it can be cases where one person uses int, another double, and so on. To avoid such conflicts, we often use types for data types. A simple example is shown below. Example Live Demo import std.stdio; alias int myAppNumber; alias string myAppString; void main() { myAppNumber i = 10; myAppString s = “TestString”; writeln(i,s); } When the above code is compiled and executed, it produces the following result − 10TestString Alias for Class Variables There is often a requirement where we need to access the member variables of the superclass in the subclass, this can made possible with alias, possibly under a different name. In case you are new to the the concept of classes and inheritance, have a look at the tutorial on classes and inheritance before starting with this section. Example A simple example is shown below. Live Demo import std.stdio; class Shape { int area; } class Square : Shape { string name() const @property { return “Square”; } alias Shape.area squareArea; } void main() { auto square = new Square; square.squareArea = 42; writeln(square.name); writeln(square.squareArea); } When the above code is compiled and executed, it produces the following result − Square 42 Alias This Alias this provides the capability of automatic type conversions of user-defined types. The syntax is shown below where the keywords alias and this are written on either sides of the member variable or member function. alias member_variable_or_member_function this; Example An example is shown below to show the power of alias this. Live Demo import std.stdio; struct Rectangle { long length; long breadth; double value() const @property { return cast(double) length * breadth; } alias value this; } double volume(double rectangle, double height) { return rectangle * height; } void main() { auto rectangle = Rectangle(2, 3); writeln(volume(rectangle, 5)); } In the above example, you can see that the struct rectangle is converted to double value with the help of alias this method. When the above code is compiled and executed, it produces the following result − 30 Print Page Previous Next Advertisements ”;

D Programming – Mixins ”; Previous Next Mixins are structs that allow mixing of the generated code into the source code. Mixins can be of the following types − String Mixins Template Mixins Mixin name spaces String Mixins D has the capability to insert code as string as long as that string is known at compile time. The syntax of string mixins is shown below − mixin (compile_time_generated_string) Example A simple example for string mixins is shown below. Live Demo import std.stdio; void main() { mixin(`writeln(“Hello World!”);`); } When the above code is compiled and executed, it produces the following result − Hello World! Here is another example where we can pass the string in compile time so that mixins can use the functions to reuse code. It is shown below. Live Demo import std.stdio; string print(string s) { return `writeln(“` ~ s ~ `”);`; } void main() { mixin (print(“str1”)); mixin (print(“str2”)); } When the above code is compiled and executed, it produces the following result − str1 str2 Template Mixins D templates define common code patterns, for the compiler to generate actual instances from that pattern. The templates can generate functions, structs, unions, classes, interfaces, and any other legal D code. The syntax of template mixins is as shown below. mixin a_template!(template_parameters) A simple example for string mixins is shown below where we create a template with class Department and a mixin instantiating a template and hence making the the functions setName and printNames available to the structure college. Example Live Demo import std.stdio; template Department(T, size_t count) { T[count] names; void setName(size_t index, T name) { names[index] = name; } void printNames() { writeln(“The names”); foreach (i, name; names) { writeln(i,” : “, name); } } } struct College { mixin Department!(string, 2); } void main() { auto college = College(); college.setName(0, “name1”); college.setName(1, “name2”); college.printNames(); } When the above code is compiled and executed, it produces the following result − The names 0 : name1 1 : name2 Mixin Name Spaces Mixin name spaces are used to avoid ambiguities in template mixins. For example, there can be two variables, one defined explicitly in main and the other is mixed in. When a mixed-in name is the same as a name that is in the surrounding scope, then the name that is in the surrounding scope gets used. This example is shown below. Example Live Demo import std.stdio; template Person() { string name; void print() { writeln(name); } } void main() { string name; mixin Person a; name = “name 1”; writeln(name); a.name = “name 2″; print(); } When the above code is compiled and executed, it produces the following result − name 1 name 2 Print Page Previous Next Advertisements ”;

D – Contract Programming ”; Previous Next Contract programming in D programming is focused on providing a simple and understandable means of error handling. Contract programming in D are implemented by three types of code blocks − body block in block out block Body Block in D Body block contains the actual functionality code of execution. The in and out blocks are optional while the body block is mandatory. A simple syntax is shown below. return_type function_name(function_params) in { // in block } out (result) { // in block } body { // actual function block } In Block for Pre Conditions in D In block is for simple pre conditions that verify whether the input parameters are acceptable and in range that can be handled by the code. A benefit of an in block is that all of the entry conditions can be kept together and separate from the actual body of the function. A simple precondition for validating password for its minimum length is shown below. Live Demo import std.stdio; import std.string; bool isValid(string password) in { assert(password.length>=5); } body { // other conditions return true; } void main() { writeln(isValid(“password”)); } When the above code is compiled and executed, it reads the file created in previous section and produces the following result − true Out Blocks for Post Conditions in D The out block takes care of the return values from the function. It validates the return value is in expected range. A simple example containing both in and out is shown below that converts months, year to a combined decimal age form. Live Demo import std.stdio; import std.string; double getAge(double months,double years) in { assert(months >= 0); assert(months <= 12); } out (result) { assert(result>=years); } body { return years + months/12; } void main () { writeln(getAge(10,12)); } When the above code is compiled and executed, it reads the file created in previous section and produces the following result − 12.8333 Print Page Previous Next Advertisements ”;

D Programming – Overloading ”; Previous Next D allows you to specify more than one definition for a function name or an operator in the same scope, which is called function overloading and operator overloading respectively. An overloaded declaration is a declaration that had been declared with the same name as a previous declaration in the same scope, except that both declarations have different arguments and obviously different definition (implementation). When you call an overloaded function or operator, the compiler determines the most appropriate definition to use by comparing the argument types you used to call the function or operator with the parameter types specified in the definitions. The process of selecting the most appropriate overloaded function or operator is called overload resolution.. Function Overloading You can have multiple definitions for the same function name in the same scope. The definition of the function must differ from each other by the types and/or the number of arguments in the argument list. You cannot overload function declarations that differ only by return type. Example The following example uses same function print() to print different data types − Live Demo import std.stdio; import std.string; class printData { public: void print(int i) { writeln(“Printing int: “,i); } void print(double f) { writeln(“Printing float: “,f ); } void print(string s) { writeln(“Printing string: “,s); } }; void main() { printData pd = new printData(); // Call print to print integer pd.print(5); // Call print to print float pd.print(500.263); // Call print to print character pd.print(“Hello D”); } When the above code is compiled and executed, it produces the following result − Printing int: 5 Printing float: 500.263 Printing string: Hello D Operator Overloading You can redefine or overload most of the built-in operators available in D. Thus a programmer can use operators with user-defined types as well. Operators can be overloaded using string op followed by Add, Sub, and so on based on the operator that is being overloaded. We can overload the operator + to add two boxes as shown below. Box opAdd(Box b) { Box box = new Box(); box.length = this.length + b.length; box.breadth = this.breadth + b.breadth; box.height = this.height + b.height; return box; } The following example shows the concept of operator overloading using a member function. Here an object is passed as an argument whose properties are accessed using this object. The object which calls this operator can be accessed using this operator as explained below − Live Demo import std.stdio; class Box { public: double getVolume() { return length * breadth * height; } void setLength( double len ) { length = len; } void setBreadth( double bre ) { breadth = bre; } void setHeight( double hei ) { height = hei; } Box opAdd(Box b) { Box box = new Box(); box.length = this.length + b.length; box.breadth = this.breadth + b.breadth; box.height = this.height + b.height; return box; } private: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; // Main function for the program void main( ) { Box box1 = new Box(); // Declare box1 of type Box Box box2 = new Box(); // Declare box2 of type Box Box box3 = new Box(); // Declare box3 of type Box double volume = 0.0; // Store the volume of a box here // box 1 specification box1.setLength(6.0); box1.setBreadth(7.0); box1.setHeight(5.0); // box 2 specification box2.setLength(12.0); box2.setBreadth(13.0); box2.setHeight(10.0); // volume of box 1 volume = box1.getVolume(); writeln(“Volume of Box1 : “, volume); // volume of box 2 volume = box2.getVolume(); writeln(“Volume of Box2 : “, volume); // Add two object as follows: box3 = box1 + box2; // volume of box 3 volume = box3.getVolume(); writeln(“Volume of Box3 : “, volume); } When the above code is compiled and executed, it produces the following result − Volume of Box1 : 210 Volume of Box2 : 1560 Volume of Box3 : 5400 Operator Overloading Types Basically, there are three types of operator overloading as listed below. Sr.No. Overloading Types 1 Unary Operators Overloading 2 Binary Operators Overloading 3 Comparison Operators Overloading Print Page Previous Next Advertisements ”;

D Programming – Exception Handling ”; Previous Next An exception is a problem that arises during the execution of a program. A D exception is a response to an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero. Exceptions provide a way to transfer control from one part of a program to another. D exception handling is built upon three keywords try, catch, and throw. throw − A program throws an exception when a problem shows up. This is done using a throw keyword. catch − A program catches an exception with an exception handler at the place in a program where you want to handle the problem. The catch keyword indicates the catching of an exception. try − A try block identifies a block of code for which particular exceptions are activated. It is followed by one or more catch blocks. Assuming a block will raise an exception, a method catches an exception using a combination of the try and catch keywords. A try/catch block is placed around the code that might generate an exception. Code within a try/catch block is referred to as protected code, and the syntax for using try/catch looks like the following − try { // protected code } catch( ExceptionName e1 ) { // catch block } catch( ExceptionName e2 ) { // catch block } catch( ExceptionName eN ) { // catch block } You can list down multiple catch statements to catch different type of exceptions in case your try block raises more than one exception in different situations. Throwing Exceptions in D Exceptions can be thrown anywhere within a code block using throw statements. The operand of the throw statements determines a type for the exception and can be any expression and the type of the result of the expression determines the type of exception thrown. The following example throws an exception when dividing by zero condition occurs − Example double division(int a, int b) { if( b == 0 ) { throw new Exception(“Division by zero condition!”); } return (a/b); } Catching Exceptions in D The catch block following the try block catches any exception. You can specify what type of exception you want to catch and this is determined by the exception declaration that appears in parentheses following the keyword catch. try { // protected code } catch( ExceptionName e ) { // code to handle ExceptionName exception } The above code catches an exception of ExceptionName type. If you want to specify that a catch block should handle any type of exception that is thrown in a try block, you must put an ellipsis,…, between the parentheses enclosing the exception declaration as follows − try { // protected code } catch(…) { // code to handle any exception } The following example throws a division by zero exception. It is caught in catch block. Live Demo import std.stdio; import std.string; string division(int a, int b) { string result = “”; try { if( b == 0 ) { throw new Exception(“Cannot divide by zero!”); } else { result = format(“%s”,a/b); } } catch (Exception e) { result = e.msg; } return result; } void main () { int x = 50; int y = 0; writeln(division(x, y)); y = 10; writeln(division(x, y)); } When the above code is compiled and executed, it reads the file created in previous section and produces the following result − Cannot divide by zero! 5 Print Page Previous Next Advertisements ”;

D Programming – Abstract Classes ”; Previous Next Abstraction refers to the ability to make a class abstract in OOP. An abstract class is one that cannot be instantiated. All other functionality of the class still exists, and its fields, methods, and constructors are all accessed in the same manner. You just cannot create an instance of the abstract class. If a class is abstract and cannot be instantiated, the class does not have much use unless it is subclass. This is typically how abstract classes come about during the design phase. A parent class contains the common functionality of a collection of child classes, but the parent class itself is too abstract to be used on its own. Using Abstract Class in D Use the abstract keyword to declare a class abstract. The keyword appears in the class declaration somewhere before the class keyword. The following shows an example of how abstract class can be inherited and used. Example Live Demo import std.stdio; import std.string; import std.datetime; abstract class Person { int birthYear, birthDay, birthMonth; string name; int getAge() { SysTime sysTime = Clock.currTime(); return sysTime.year – birthYear; } } class Employee : Person { int empID; } void main() { Employee emp = new Employee(); emp.empID = 101; emp.birthYear = 1980; emp.birthDay = 10; emp.birthMonth = 10; emp.name = “Emp1”; writeln(emp.name); writeln(emp.getAge); } When we compile and run the above program, we will get the following output. Emp1 37 Abstract Functions Similar to functions, classes can also be abstract. The implementation of such function is not given in its class but should be provided in the class that inherits the class with abstract function. The above example is updated with abstract function. Example Live Demo import std.stdio; import std.string; import std.datetime; abstract class Person { int birthYear, birthDay, birthMonth; string name; int getAge() { SysTime sysTime = Clock.currTime(); return sysTime.year – birthYear; } abstract void print(); } class Employee : Person { int empID; override void print() { writeln(“The employee details are as follows:”); writeln(“Emp ID: “, this.empID); writeln(“Emp Name: “, this.name); writeln(“Age: “,this.getAge); } } void main() { Employee emp = new Employee(); emp.empID = 101; emp.birthYear = 1980; emp.birthDay = 10; emp.birthMonth = 10; emp.name = “Emp1″; emp.print(); } When we compile and run the above program, we will get the following output. The employee details are as follows: Emp ID: 101 Emp Name: Emp1 Age: 37 Print Page Previous Next Advertisements ”;

D Programming – File I/O ”; Previous Next Files are represented by the File struct of the std.stdio module. A file represents a sequence of bytes, does not matter if it is a text file or binary file. D programming language provides access on high level functions as well as low level (OS level) calls to handle file on your storage devices. Opening Files in D The standard input and output streams stdin and stdout are already open when programs start running. They are ready to be used. On the other hand, files must first be opened by specifying the name of the file and the access rights that are needed. File file = File(filepath, “mode”); Here, filename is string literal, which you use to name the file and access mode can have one of the following values − Sr.No. Mode & Description 1 r Opens an existing text file for reading purpose. 2 w Opens a text file for writing, if it does not exist then a new file is created. Here your program will start writing content from the beginning of the file. 3 a Opens a text file for writing in appending mode, if it does not exist then a new file is created. Here your program will start appending content in the existing file content. 4 r+ Opens a text file for reading and writing both. 5 w+ Opens a text file for reading and writing both. It first truncate the file to zero length if it exists otherwise create the file if it does not exist. 6 a+ Opens a text file for reading and writing both. It creates the file if it does not exist. The reading will start from the beginning but writing can only be appended. Closing a File in D To close a file, use the file.close() function where file holds the file reference. The prototype of this function is − file.close(); Any file that has been opened by a program must be closed when the program finishes using that file. In most cases the files need not be closed explicitly; they are closed automatically when File objects are terminated. Writing a File in D file.writeln is used to write to an open file. file.writeln(“hello”); import std.stdio; import std.file; void main() { File file = File(“test.txt”, “w”); file.writeln(“hello”); file.close(); } When the above code is compiled and executed, it creates a new file test.txt in the directory that it has been started under (in the program working directory). Reading a File in D The following method reads a single line from a file − string s = file.readln(); A complete example of read and write is shown below. import std.stdio; import std.file; void main() { File file = File(“test.txt”, “w”); file.writeln(“hello”); file.close(); file = File(“test.txt”, “r”); string s = file.readln(); writeln(s); file.close(); } When the above code is compiled and executed, it reads the file created in previous section and produces the following result − hello Here is another example for reading file till end of file. import std.stdio; import std.string; void main() { File file = File(“test.txt”, “w”); file.writeln(“hello”); file.writeln(“world”); file.close(); file = File(“test.txt”, “r”); while (!file.eof()) { string line = chomp(file.readln()); writeln(“line -“, line); } } When the above code is compiled and executed, it reads the file created in previous section and produces the following result − line -hello line -world line – You can see in the above example an empty third line since writeln takes it to next line once it is executed. Print Page Previous Next Advertisements ”;

D Programming – Loops ”; Previous Next There may be a situation, when you need to execute a block of code several number of times. In general, statements are executed sequentially: The first statement in a function is executed first, followed by the second, and so on. Programming languages provide various control structures that allow more complicated execution paths. A loop statement executes a statement or group of statements multiple times. The following general form of a loop statement in mostly used in the programming languages − D programming language provides the following types of loop to handle looping requirements. Click the following links to check their detail. Sr.No. Loop Type & Description 1 while loop It repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body. 2 for loop It executes a sequence of statements multiple times and abbreviates the code that manages the loop variable. 3 do…while loop Like a while statement, except that it tests the condition at the end of the loop body. 4 nested loops You can use one or more loop inside any another while, for, or do..while loop. Loop Control Statements Loop control statements change execution from its normal sequence. When execution leaves a scope, all automatic objects that were created in that scope are destroyed. D supports the following control statements − Sr.No. Control Statement & Description 1 break statement Terminates the loop or switch statement and transfers execution to the statement immediately following the loop or switch. 2 continue statement Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating. The Infinite Loop A loop becomes infinite loop if a condition never becomes false. The for loop is traditionally used for this purpose. Since none of the three expressions that form the for loop are required, you can make an endless loop by leaving the conditional expression empty. import std.stdio; int main () { for( ; ; ) { writefln(“This loop will run forever.”); } return 0; } When the conditional expression is absent, it is assumed to be true. You may have an initialization and increment expression, but D programmers more commonly use the for(;;) construct to signify an infinite loop. NOTE − You can terminate an infinite loop by pressing Ctrl + C keys. Print Page Previous Next Advertisements ”;

D Programming – Literals ”; Previous Next Constant values that are typed in the program as a part of the source code are called literals. Literals can be of any of the basic data types and can be divided into Integer Numerals, Floating-Point Numerals, Characters, Strings, and Boolean Values. Again, literals are treated just like regular variables except that their values cannot be modified after their definition. Integer Literals An integer literal can be a of the following types − Decimal uses the normal number represention with the first digit cannot be 0 as that digit is reserved for indicating the octal system.This does not include 0 on its own: 0 is zero. Octal uses 0 as prefix to number. Binary uses 0b or 0B as prefix. Hexadecimal uses 0x or 0X as prefix. An integer literal can also have a suffix that is a combination of U and L, for unsigned and long, respectively. The suffix can be uppercase or lowercase and can be in any order. When you don’t use a suffix, the compiler itself chooses between int, uint, long, and ulong based on the magnitude of the value. Here are some examples of integer literals − 212 // Legal 215u // Legal 0xFeeL // Legal 078 // Illegal: 8 is not an octal digit 032UU // Illegal: cannot repeat a suffix Following are other examples of various types of integer literals − 85 // decimal 0213 // octal 0x4b // hexadecimal 30 // int 30u // unsigned int 30l // long 30ul // unsigned long 0b001 // binary Floating Point Literals The floating point literals can be specified in either the decimal system as in 1.568 or in the hexadecimal system as in 0x91.bc. In the decimal system, an exponent can be represented by adding the character e or E and a number after that. For example, 2.3e4 means “2.3 times 10 to the power of 4”. A “+” character may be specified before the value of the exponent, but it has no effect. For example 2.3e4 and 2.3e + 4 are the same. The “-” character added before the value of the exponent changes the meaning to be “divided by 10 to the power of”. For example, 2.3e-2 means “2.3 divided by 10 to the power of 2”. In the hexadecimal system, the value starts with either 0x or 0X. The exponent is specified by p or P instead of e or E. The exponent does not mean “10 to the power of”, but “2 to the power of”. For example, the P4 in 0xabc.defP4 means “abc.de times 2 to the power of 4”. Here are some examples of floating-point literals − 3.14159 // Legal 314159E-5L // Legal 510E // Illegal: incomplete exponent 210f // Illegal: no decimal or exponent .e55 // Illegal: missing integer or fraction 0xabc.defP4 // Legal Hexa decimal with exponent 0xabc.defe4 // Legal Hexa decimal without exponent. By default, the type of a floating point literal is double. The f and F mean float, and the L specifier means real. Boolean Literals There are two Boolean literals and they are part of standard D keywords − A value of true representing true. A value of false representing false. You should not consider the value of true equal to 1 and value of false equal to 0. Character Literals Character literals are enclosed in single quotes. A character literal can be a plain character (e.g., ”x”), an escape sequence (e.g., ”t”), ASCII character (e.g., ”x21”), Unicode character (e.g., ”u011e”) or as named character (e.g. ”&copy”,”♥”, ”€” ). There are certain characters in D when they are preceded by a backslash they will have special meaning and they are used to represent like newline (n) or tab (t). Here, you have a list of some of such escape sequence codes − Escape sequence Meaning \ character ” ” character “ ” character ? ? character a Alert or bell b Backspace f Form feed n Newline r Carriage return t Horizontal tab v Vertical tab The following example shows few escape sequence characters − Live Demo import std.stdio; int main(string[] args) { writefln(“HellotWorld%cn”,”x21”); writefln(“Have a good day%c”,”x21”); return 0; } When the above code is compiled and executed, it produces the following result − Hello World! Have a good day! String Literals String literals are enclosed in double quotes. A string contains characters that are similar to character literals: plain characters, escape sequences, and universal characters. You can break a long line into multiple lines using string literals and separate them using whitespaces. Here are some examples of string literals − import std.stdio; int main(string[] args) { writeln(q”MY_DELIMITER Hello World Have a good day MY_DELIMITER”); writefln(“Have a good day%c”,”x21”); auto str = q{int value = 20; ++value;}; writeln(str); } In the above example, you can find the use of q”MY_DELIMITER MY_DELIMITER” to represent multi line characters. Also, you can see q{} to represent an D language statement itself. Print Page Previous Next Advertisements ”;