Category: d Programming

D Programming – Classes & Objects ”; Previous Next Classes are the central feature of D programming that supports object-oriented programming and are often called user-defined types. A class is used to specify the form of an object and it combines data representation and methods for manipulating that data into one neat package. The data and functions within a class are called members of the class. D Class Definitions When you define a class, you define a blueprint for a data type. This does not actually define any data, but it defines what the class name means, that is, what an object of the class will consist of and what operations can be performed on such an object. A class definition starts with the keyword class followed by the class name; and the class body, enclosed by a pair of curly braces. A class definition must be followed either by a semicolon or a list of declarations. For example, we defined the Box data type using the keyword class as follows − class Box { public: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box } The keyword public determines the access attributes of the members of the class that follow it. A public member can be accessed from outside the class anywhere within the scope of the class object. You can also specify the members of a class as private or protected which we will discuss in a sub-section. Defining D Objects A class provides the blueprints for objects, so basically an object is created from a class. You declare objects of a class with exactly the same sort of declaration that you declare variables of basic types. The following statements declare two objects of class Box − Box Box1; // Declare Box1 of type Box Box Box2; // Declare Box2 of type Box Both of the objects Box1 and Box2 have their own copy of data members. Accessing the Data Members The public data members of objects of a class can be accessed using the direct member access operator (.). Let us try the following example to make the things clear − Live Demo import std.stdio; class Box { public: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box } void main() { Box box1 = new Box(); // Declare Box1 of type Box Box box2 = new Box(); // Declare Box2 of type Box double volume = 0.0; // Store the volume of a box here // box 1 specification box1.height = 5.0; box1.length = 6.0; box1.breadth = 7.0; // box 2 specification box2.height = 10.0; box2.length = 12.0; box2.breadth = 13.0; // volume of box 1 volume = box1.height * box1.length * box1.breadth; writeln(“Volume of Box1 : “,volume); // volume of box 2 volume = box2.height * box2.length * box2.breadth; writeln(“Volume of Box2 : “, volume); } When the above code is compiled and executed, it produces the following result − Volume of Box1 : 210 Volume of Box2 : 1560 It is important to note that private and protected members can not be accessed directly using direct member access operator (.). Shortly you will learn how private and protected members can be accessed. Classes and Objects in D So far, you have got very basic idea about D Classes and Objects. There are further interesting concepts related to D Classes and Objects which we will discuss in various sub-sections listed below − Sr.No. Concept & Description 1 Class member functions A member function of a class is a function that has its definition or its prototype within the class definition like any other variable. 2 Class access modifiers A class member can be defined as public, private or protected. By default members would be assumed as private. 3 Constructor & destructor A class constructor is a special function in a class that is called when a new object of the class is created. A destructor is also a special function which is called when created object is deleted. 4 The this pointer in D Every object has a special pointer this which points to the object itself. 5 Pointer to D classes A pointer to a class is done exactly the same way a pointer to a structure is. In fact a class is really just a structure with functions in it. 6 Static members of a class Both data members and function members of a class can be declared as static. Print Page Previous Next Advertisements ”;

D Programming – Interfaces ”; Previous Next An interface is a way of forcing the classes that inherit from it to have to implement certain functions or variables. Functions must not be implemented in an interface because they are always implemented in the classes that inherit from the interface. An interface is created using the interface keyword instead of the class keyword even though the two are similar in a lot of ways. When you want to inherit from an interface and the class already inherits from another class then you need to separate the name of the class and the name of the interface with a comma. Let us look at an simple example that explains the use of an interface. Example Live Demo import std.stdio; // Base class interface Shape { public: void setWidth(int w); void setHeight(int h); } // Derived class class Rectangle: Shape { int width; int height; public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } int getArea() { return (width * height); } } void main() { Rectangle Rect = new Rectangle(); Rect.setWidth(5); Rect.setHeight(7); // Print the area of the object. writeln(“Total area: “, Rect.getArea()); } When the above code is compiled and executed, it produces the following result − Total area: 35 Interface with Final and Static Functions in D An interface can have final and static method for which definitions should be included in interface itself. These functions cannot be overriden by the derived class. A simple example is shown below. Example Live Demo import std.stdio; // Base class interface Shape { public: void setWidth(int w); void setHeight(int h); static void myfunction1() { writeln(“This is a static method”); } final void myfunction2() { writeln(“This is a final method”); } } // Derived class class Rectangle: Shape { int width; int height; public: void setWidth(int w) { width = w; } void setHeight(int h) { height = h; } int getArea() { return (width * height); } } void main() { Rectangle rect = new Rectangle(); rect.setWidth(5); rect.setHeight(7); // Print the area of the object. writeln(“Total area: “, rect.getArea()); rect.myfunction1(); rect.myfunction2(); } When the above code is compiled and executed, it produces the following result − Total area: 35 This is a static method This is a final method Print Page Previous Next Advertisements ”;

D Programming – Decisions ”; Previous Next The decision making structures contain condition to be evaluated along with the two sets of statements to be executed. One set of statements is executed if the condition it true and another set of statements is executed if the condition is false. The following is the general form of a typical decision making structure found in most of the programming languages − D programming language assumes any non-zero and non-null values as true, and if it is either zero or null, then it is assumed as false value. D programming language provides the following types of decision making statements. Sr.No. Statement & Description 1 if statement An if statement consists of a boolean expression followed by one or more statements. 2 if…else statement An if statement can be followed by an optional else statement, which executes when the boolean expression is false. 3 nested if statements You can use one if or else if statement inside another if or else if statement(s). 4 switch statement A switch statement allows a variable to be tested for equality against a list of values. 5 nested switch statements You can use one switch statement inside another switch statement(s). The ? : Operator in D We have covered conditional operator ? : in previous chapter which can be used to replace if…else statements. It has the following general form Exp1 ? Exp2 : Exp3; Where Exp1, Exp2, and Exp3 are expressions. Notice the use and placement of the colon. The value of a ? expression is determined as follows − Exp1 is evaluated. If it is true, then Exp2 is evaluated and becomes the value of the entire ? expression. If Exp1 is false, then Exp3 is evaluated and its value becomes the value of the expression. Print Page Previous Next Advertisements ”;

D Programming – Templates ”; Previous Next Templates are the foundation of generic programming, which involve writing code in a way that is independent of any particular type. A template is a blueprint or formula for creating a generic class or a function. Templates are the feature that allows describing the code as a pattern, for the compiler to generate program code automatically. Parts of the source code may be left to the compiler to be filled in until that part is actually used in the program. The compiler fills in the missing parts. Function Template Defining a function as a template is leaving one or more of the types that it uses as unspecified, to be deduced later by the compiler. The types that are being left unspecified are defined within the template parameter list, which comes between the name of the function and the function parameter list. For that reason, function templates have two parameter lists − template parameter list function parameter list Live Demo import std.stdio; void print(T)(T value) { writefln(“%s”, value); } void main() { print(42); print(1.2); print(“test”); } If we compile and run above code, this would produce the following result − 42 1.2 test Function Template with Multiple Type Parameters There can be multiple parameter types. They are shown in the following example. Live Demo import std.stdio; void print(T1, T2)(T1 value1, T2 value2) { writefln(” %s %s”, value1, value2); } void main() { print(42, “Test”); print(1.2, 33); } If we compile and run above code, this would produce the following result − 42 Test 1.2 33 Class Templates Just as we can define function templates, we can also define class templates. The following example defines class Stack and implements generic methods to push and pop the elements from the stack. Live Demo import std.stdio; import std.string; class Stack(T) { private: T[] elements; public: void push(T element) { elements ~= element; } void pop() { –elements.length; } T top() const @property { return elements[$ – 1]; } size_t length() const @property { return elements.length; } } void main() { auto stack = new Stack!string; stack.push(“Test1”); stack.push(“Test2″); writeln(stack.top); writeln(stack.length); stack.pop; writeln(stack.top); writeln(stack.length); } When the above code is compiled and executed, it produces the following result − Test2 2 Test1 1 Print Page Previous Next Advertisements ”;

D Programming – Data Types ”; Previous Next In the D programming language, data types refer to an extensive system used for declaring variables or functions of different types. The type of a variable determines how much space it occupies in storage and how the stored bit pattern is interpreted. The types in D can be classified as follows − Sr.No. Types & Description 1 Basic Types They are arithmetic types and consist of the three types: (a) integer, (b) floating-point, and (c) character. 2 Enumerated types They are again arithmetic types. They are used to define variables that can only be assigned certain discrete integer values throughout the program. 3 The type void The type specifier void indicates that no value is available. 4 Derived types They include (a) Pointer types, (b) Array types, (c) Structure types, (d) Union types, and (e) Function types. The array types and structure types are referred to collectively as the aggregate types. The type of a function specifies the type of the function”s return value. We will see basic types in the following section whereas other types will be covered in the upcoming chapters. Integer Types The following table gives lists standard integer types with their storage sizes and value ranges − Type Storage size Value range bool 1 byte false or true byte 1 byte -128 to 127 ubyte 1 byte 0 to 255 int 4 bytes -2,147,483,648 to 2,147,483,647 uint 4 bytes 0 to 4,294,967,295 short 2 bytes -32,768 to 32,767 ushort 2 bytes 0 to 65,535 long 8 bytes -9223372036854775808 to 9223372036854775807 ulong 8 bytes 0 to 18446744073709551615 To get the exact size of a type or a variable, you can use the sizeof operator. The expression type.(sizeof) yields the storage size of the object or type in bytes. The following example gets the size of int type on any machine − Live Demo import std.stdio; int main() { writeln(“Length in bytes: “, ulong.sizeof); return 0; } When you compile and execute the above program, it produces the following result − Length in bytes: 8 Floating-Point Types The following table mentions standard float-point types with storage sizes, value ranges, and their purpose − Type Storage size Value range Purpose float 4 bytes 1.17549e-38 to 3.40282e+38 6 decimal places double 8 bytes 2.22507e-308 to 1.79769e+308 15 decimal places real 10 bytes 3.3621e-4932 to 1.18973e+4932 either the largest floating point type that the hardware supports, or double; whichever is larger ifloat 4 bytes 1.17549e-38i to 3.40282e+38i imaginary value type of float idouble 8 bytes 2.22507e-308i to 1.79769e+308i imaginary value type of double ireal 10 bytes 3.3621e-4932 to 1.18973e+4932 imaginary value type of real cfloat 8 bytes 1.17549e-38+1.17549e-38i to 3.40282e+38+3.40282e+38i complex number type made of two floats cdouble 16 bytes 2.22507e-308+2.22507e-308i to 1.79769e+308+1.79769e+308i complex number type made of two doubles creal 20 bytes 3.3621e-4932+3.3621e-4932i to 1.18973e+4932+1.18973e+4932i complex number type made of two reals The following example prints storage space taken by a float type and its range values − Live Demo import std.stdio; int main() { writeln(“Length in bytes: “, float.sizeof); return 0; } When you compile and execute the above program, it produces the following result on Linux − Length in bytes: 4 Character Types The following table lists standard character types with storage sizes and its purpose. Type Storage size Purpose char 1 byte UTF-8 code unit wchar 2 bytes UTF-16 code unit dchar 4 bytes UTF-32 code unit and Unicode code point The following example prints storage space taken by a char type. Live Demo import std.stdio; int main() { writeln(“Length in bytes: “, char.sizeof); return 0; } When you compile and execute the above program, it produces the following result − Length in bytes: 1 The void Type The void type specifies that no value is available. It is used in two kinds of situations − Sr.No. Types & Description 1 Function returns as void There are various functions in D which do not return value or you can say they return void. A function with no return value has the return type as void. For example, void exit (int status); 2 Function arguments as void There are various functions in D which do not accept any parameter. A function with no parameter can accept as a void. For example, int rand(void); The void type may not be understood to you at this point, so let us proceed and we will cover these concepts in upcoming chapters. Print Page Previous Next Advertisements ”;

D Programming – Quick Guide ”; Previous Next D Programming – Overview D programming language is an object-oriented multi-paradigm system programming language developed by Walter Bright of Digital Mars. Its development started in 1999 and was first released in 2001. The major version of D(1.0) was released in 2007. Currently, we have D2 version of D. D is language with syntax being C style and uses static typing. There are many features of C and C++ in D but also there are some features from these language not included part of D. Some of the notable additions to D includes, Unit testing True modules Garbage collection First class arrays Free and open Associative arrays Dynamic arrays Inner classes Closures Anonymous functions Lazy evaluation Closures Multiple Paradigms D is a multiple paradigm programming language. The multiple paradigms includes, Imperative Object Oriented Meta programming Functional Concurrent Example Live Demo import std.stdio; void main(string[] args) { writeln(“Hello World!”); } Learning D The most important thing to do when learning D is to focus on concepts and not get lost in language technical details. The purpose of learning a programming language is to become a better programmer; that is, to become more effective at designing and implementing new systems and at maintaining old ones. Scope of D D programming has some interesting features and the official D programming site claims that D is convinient, powerful and efficient. D programming adds many features in the core language which C language has provided in the form of Standard libraries such as resizable array and string function. D makes an excellent second language for intermediate to advanced programmers. D is better in handling memory and managing the pointers that often causes trouble in C++. D programming is intended mainly on new programs that conversion of existing programs. It provides built in testing and verification an ideal for large new project that will be written with millions of lines of code by large teams. D Programming – Environment Local Environment Setup for D If you are still willing to set up your environment for D programming language, you need the following two softwares available on your computer, (a) Text Editor,(b)D Compiler. Text Editor for D Programming This will be used to type your program. Examples of few editors include Windows Notepad, OS Edit command, Brief, Epsilon, EMACS, and vim or vi. Name and version of text editor can vary on different operating systems. For example, Notepad will be used on Windows, and vim or vi can be used on windows as well as Linux or UNIX. The files you create with your editor are called source files and contain program source code. The source files for D programs are named with the extension “.d“. Before starting your programming, make sure you have one text editor in place and you have enough experience to write a computer program, save it in a file, build it and finally execute it. The D Compiler Most current D implementations compile directly into machine code for efficient execution. We have multiple D compilers available and it includes the following. DMD − The Digital Mars D compiler is the official D compiler by Walter Bright. GDC − A front-end for the GCC back-end, built using the open DMD compiler source code. LDC − A compiler based on the DMD front-end that uses LLVM as its compiler back-end. The above different compilers can be downloaded from D downloads We will be using D version 2 and we recommend not to download D1. Lets have a helloWorld.d program as follows. We will use this as first program we run on platform you choose. Live Demo import std.stdio; void main(string[] args) { writeln(“Hello World!”); } We can see the following output. $ hello world Installation of D on Windows Download the windows installer. Run the downloaded executable to install the D which can be done by following the on screen instructions. Now we can build and run a d file say helloWorld.d by switching to folder containing the file using cd and then using the following steps − C:DProgramming> DMD helloWorld.d C:DProgramming> helloWorld We can see the following output. hello world C:DProgramming is the folder, I am using to save my samples. You can change it to the folder that you have saved D programs. Installation of D on Ubuntu/Debian Download the debian installer. Run the downloaded executable to install the D which can be done by following the on screen instructions. Now we can build and run a d file say helloWorld.d by switching to folder containing the file using cd and then using the following steps − $ dmd helloWorld.d $ ./helloWorld We can see the following output. $ hello world Installation of D on Mac OS X Download the Mac installer. Run the downloaded executable to install the D which can be done by following the on screen instructions. Now we can build and run a d file say helloWorld.d by switching to folder containing the file using cd and then using the following steps − $ dmd helloWorld.d $ ./helloWorld We can see the following output. $ hello world Installation of D on Fedora Download the fedora installer. Run the downloaded executable to install the D which can be done by following the on screen instructions. Now we can build and run a d file say helloWorld.d by switching to folder containing the file using cd and then using the following steps − $ dmd helloWorld.d $ ./helloWorld We can see the following output. $ hello world Installation of D on OpenSUSE Download the OpenSUSE installer. Run the downloaded executable to install the D which can be done by following the on screen instructions. Now we can build and run a d file say helloWorld.d by switching to folder containing the file using cd and then using the following steps − $ dmd helloWorld.d $ ./helloWorld We can see the following output. $ hello world D IDE We have

Discuss D Programming ”; Previous Next D programming language is an object-oriented multi-paradigm system programming language. D programming is actually developed by re-engineering C++ programming language, but it is distinct programming language that not only takes in some features of C++ but also some features of other programming languages such as Java, C#, Python, and Ruby. This tutorial covers various topics ranging from the basics of the D programming language to advanced OOP concepts along with the supplementary examples. Print Page Previous Next Advertisements ”;

D Programming – Encapsulation ”; Previous Next All D programs are composed of the following two fundamental elements − Program statements (code) − This is the part of a program that performs actions and they are called functions. Program data − It is the information of the program which affected by the program functions. Encapsulation is an Object Oriented Programming concept that binds data and functions that manipulate the data together, and that keeps both safe from outside interference and misuse. Data encapsulation led to the important OOP concept of data hiding. Data encapsulation is a mechanism of bundling the data, and the functions that use them and data abstraction is a mechanism of exposing only the interfaces and hiding the implementation details from the user. D supports the properties of encapsulation and data hiding through the creation of user-defined types, called classes. We already have studied that a class can contain private, protected, and public members. By default, all items defined in a class are private. For example − class Box { public: double getVolume() { return length * breadth * height; } private: double length; // Length of a box double breadth; // Breadth of a box double height; // Height of a box }; The variables length, breadth, and height are private. This means that they can be accessed only by other members of the Box class, and not by any other part of your program. This is one way encapsulation is achieved. To make parts of a class public (i.e., accessible to other parts of your program), you must declare them after the public keyword. All variables or functions defined after the public specifier are accessible by all other functions in your program. Making one class a friend of another exposes the implementation details and reduces encapsulation. It is ideal to keep as many details of each class hidden from all other classes as possible. Data Encapsulation in D Any D program where you implement a class with public and private members is an example of data encapsulation and data abstraction. Consider the following example − Example Live Demo import std.stdio; class Adder { public: // constructor this(int i = 0) { total = i; } // interface to outside world void addNum(int number) { total += number; } // interface to outside world int getTotal() { return total; }; private: // hidden data from outside world int total; } void main( ) { Adder a = new Adder(); a.addNum(10); a.addNum(20); a.addNum(30); writeln(“Total “,a.getTotal()); } When the above code is compiled and executed, it produces the following result − Total 60 Above class adds numbers together, and returns the sum. The public members addNum and getTotal are the interfaces to the outside world and a user needs to know them to use the class. The private member total is something that is hidden from the outside world, but is needed for the class to operate properly. Class Designing Strategy in D Most of us have learned through bitter experience to make class members private by default unless we really need to expose them. That is just good encapsulation. This wisdom is applied most frequently to data members, but it applies equally to all members, including virtual functions. Print Page Previous Next Advertisements ”;

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 ”;