D programming Language
Programming in D for C++ Programmers
Download 1.66 Mb.
|
- Navigate this page:
- Defining constructors
- Base class initialization
- Comparing structs
- Creating a new typedefd type
- Operator overloading
- Namespace using declarations
- RAII (Resource Acquisition Is Initialization)
- Dynamic Closures
Programming in D for C++ ProgrammersE  very experienced C++ programmer accumulates a series of idioms and techniques which become second nature. Sometimes, when learning a new language, those idioms can be so comfortable it's hard to see how to do the equivalent in the new language. So here's a collection of common C++ techniques, and how to do the corresponding task in D.
See also: Programming in D for C Programmers
Defining constructorsThe C++ WayConstructors have the same name as the class: class Foo { Foo(int x); }; The D WayConstructors are defined with the this keyword: class Foo { this(int x) { } } which reflects how they are used in D.
Base class initializationThe C++ WayBase constructors are called using the base initializer syntax. class A { A() {... } }; class B : A { B(int x) : A() // call base constructor { ...
} };
The D WayThe base class constructor is called with the super syntax: class A { this() { ... } } class B : A { this(int x) { ... super(); // call base constructor ... }
It's superior to C++ in that the base constructor call can be flexibly placed anywhere in the derived constructor. D can also have one constructor call another one: { int a; int b;
this() { a = 7; b = foo(); } this(int x) { this();
a = x; } } Members can also be initialized to constants before the constructor is ever called, so the above example is equivalently written as: class A
{ int a = 7; int b;
this() { b = foo(); } this(int x) { this();
a = x; } }
Comparing structsThe C++ WayWhile C++ defines struct assignment in a simple, convenient manner: struct A x, y; ... x = y;
it does not for struct comparisons. Hence, to compare two struct instances for equality: #include struct A x, y; inline bool operator==(const A& x, const A& y) { return (memcmp(&x, &y, sizeof(struct A)) == 0); } ...
if (x == y) ...
Note that the operator overload must be done for every struct needing to be compared, and the implementation of that overloaded operator is free of any language help with type checking. The C++ way has an additional problem in that just inspecting the (x == y) does not give a clue what is actually happening, you have to go and find the particular overloaded operator==() that applies to verify what it really does. There's a nasty bug lurking in the memcmp() implementation of operator==(). The layout of a struct, due to alignment, can have 'holes' in it. C++ does not guarantee those holes are assigned any values, and so two different struct instances can have the same value for each member, but compare different because the holes contain different garbage. To address this, the operator==() can be implemented to do a memberwise compare. Unfortunately, this is unreliable because (1) if a member is added to the struct definition one may forget to add it to operator==(), and (2) floating point nan values compare unequal even if their bit patterns match. There just is no robust solution in C++. The D WayD does it the obvious, straightforward way: A x, y;
... if (x == y) ...
The C++ WayTypedef's in C++ are weak, that is, they really do not introduce a new type. The compiler doesn't distinguish between a typedef and its underlying type. #define HANDLE_INIT ((Handle)(-1)) typedef void *Handle; void foo(void *); void bar(Handle);
foo(h); // coding bug not caught bar(h); // ok The C++ solution is to create a dummy struct whose sole purpose is to get type checking and overloading on the new type. #define HANDLE_INIT ((void *)(-1)) struct Handle { void *ptr; Handle() { ptr = HANDLE_INIT; } // default initializer Handle(int i) { ptr = (void *)i; } operator void*() { return ptr; } // conversion to underlying type }; void bar(Handle); Handle h; bar(h);
h = func(); if (h != HANDLE_INIT) ...
The D WayNo need for idiomatic constructions like the above. Just write: typedef void *Handle = cast(void *)-1; void bar(Handle);
bar(h);
h = func(); if (h != Handle.init) ... Note how a default initializer can be supplied for the typedef as a value of the underlying type.
FriendsThe C++ WaySometimes two classes are tightly related but not by inheritance, but need to access each other's private members. This is done using friend declarations: class A
{ private: int a;
int foo(B *j); friend int abc(A *); };
{ private: int b; public: int bar(A *j); friend class A; };
int B::bar(A *j) { return j->a; }
The D WayIn D, friend access is implicit in being a member of the same module. It makes sense that tightly related classes should be in the same module, so implicitly granting friend access to other module members solves the problem neatly: module X; class A { private: static int a; public: int foo(B j) { return j.b; } }
{ private: static int b; public: int bar(A j) { return j.a; } }
The private attribute prevents other modules from accessing the members.
Operator overloadingThe C++ WayGiven a struct that creates a new arithmetic data type, it's convenient to overload the comparison operators so it can be compared against integers: struct A { virtual int operator < (int i); virtual int operator <= (int i); virtual int operator > (int i); virtual int operator >= (int i);
static int operator <= (int i, A *a) { return a >= i; } static int operator > (int i, A *a) { return a < i; } static int operator >= (int i, A *a) { return a <= i; } }; A total of 8 functions are necessary, and all the latter 4 do is just rewrite the expression so the virtual functions can be used. Note the asymmetry between the virtual functions, which have (a < i) as the left operand, and the non-virtual static function necessary to handle (i < a) operations. The D WayD recognizes that the comparison operators are all fundamentally related to each other. So only one function is necessary: struct A { int cmp(int i); } The compiler automatically interprets all the <, <=, > and >= operators in terms of the cmp function, as well as handling the cases where the left operand is not an object reference. Similar sensible rules hold for other operator overloads, making using operator overloading in D much less tedious and less error prone. Far less code needs to be written to accomplish the same effect.
The C++ WayA using-declaration in C++ is used to bring a name from a namespace scope into the current scope: namespace Foo { int x;
} using Foo::x; The D WayD uses modules instead of namespaces and #include files, and alias declarations take the place of using declarations: ---- Module Foo.d ------ module Foo; int x;
import Foo; alias Foo.x x; Alias is a much more flexible than the single purpose using declaration. Alias can be used to rename symbols, refer to template members, refer to nested class types, etc.
The C++ WayIn C++, resources like memory, etc., all need to be handled explicitly. Since destructors automatically get called when leaving a scope, RAII is implemented by putting the resource release code into the destructor: { Handle *h;
{ h->release(); } };
The D WayThe bulk of resource release problems are simply keeping track of and freeing memory. This is handled automatically in D by the garbage collector. The second common resources used are semaphores and locks, handled automatically with D's synchronized declarations and statements. The few RAII issues left are handled by auto classes. Auto classes get their destructors run when they go out of scope. auto class File { Handle h; ~this() { h.release(); } }
{ if (...)
{ auto File f = new File(); ...
} // f.~this() gets run at closing brace, even if // scope was exited via a thrown exception }
The C++ WayConsider a reusable container class. In order to be reusable, it must support a way to apply arbitrary code to each element of the container. This is done by creating an apply function that accepts a function pointer to which is passed each element of the container contents. A generic context pointer is also needed, represented here by void *p. The example here is of a trivial container class that holds an array of int's, and a user of that container that computes the maximum of those int's. struct Collection { int array[10]; void apply(void *p, void (*fp)(void *, int)) { for (int i = 0; i < sizeof(array)/sizeof(array[0]); i++) fp(p, array[i]); } }; void comp_max(void *p, int i) { int *pmax = (int *)p; if (i > *pmax) *pmax = i; }
{ int max = INT_MIN; c->apply(&max, comp_max); } The C++ way makes heavy use of pointers and casting. The casting is tedious, error prone, and loses all type safety. The D WayThe D version makes use of delegates to transmit context information for the apply function, and nested functions both to capture context information and to improve locality. class Collection { int[10] array; void apply(void delegate(int) fp) { for (int i = 0; i < array.length; i++) fp(array[i]); } } void func(Collection c) { int max = int.min; void comp_max(int i) { if (i > max) max = i; }
} Pointers are eliminated, as well as casting and generic pointers. The D version is fully type safe. An alternate method in D makes use of function literals: void func(Collection c) { int max = int.min; c.apply(delegate(int i) { if (i > max) max = i; } ); } eliminating the need to create irrelevant function names. Directory: upload upload -> 587 Return function, r i(X) r i(0) r i(1) r i(2) r i(3) 1 0 2 4 6 Thermal Station, I 2 0 1 5 6 3 0 3 5 6 10 upload -> Department of science and humanities department of mathematics part-a questions and answers upload -> The Case Against the nypd’s Quota-Driven ‘Broken Windows’ Policing What Is It? upload -> For want of a nail upload -> Traditional British values upload -> Tv shows, Made for tv movies, Mini Series & Internet Programs Shot at Paramount Ranch upload -> Ownership Models There are two different types of ownership models upload -> Police Militarization upload -> City of rising star regular meting thursday, july 14, 2016 upload -> Township of winfield Download 1.66 Mb. Share with your friends:
|