www.digitalmars.com         C & C++   DMDScript  

D - quick

reply "Brian Folan" <99541157 itb.ie> writes:
I have a project to do on D in college.(www.itb.ie).
Can some of ye just reply a couple of flash things about D, things like why
would be used instead of existing languages, and why it was made ?

I can make it available when done, if anyone is interested(deadline is this
friday).
Mar 05 2002
next sibling parent "Brian Folan" <99541157 itb.ie> writes:
Re: quick


was meant to change that subject.
Mar 05 2002
prev sibling parent reply "Brian Folan" <99541157 itb.ie> writes:
i only program in C in college, with limited c++ exposure, and i cant find
the difference between C++ and D :(
Mar 05 2002
parent reply "Pavel Minayev" <evilone omen.ru> writes:
"Brian Folan" <99541157 itb.ie> wrote in message
news:a62kuq$2tgd$1 digitaldaemon.com...

 i only program in C in college, with limited c++ exposure, and i cant find
 the difference between C++ and D :(

I recommend you to read the "Overview" and "Converting C++ to D" sections of the D manual for detailed explanations, but here are the most important (IMO) features you should be aware of: - Objects are never instantiated on stack. In C++, this is a common practice. In D, you always use operator new to create an object. Variables of type "object" are actually references to objects, and not objects themselves: /* C++ */ class Foo { ... } Foo bar; // bar is an instance of Foo Foo* baz; // baz is a pointer to instance of Foo /* D */ class Foo { ... } Foo bar; // bar is a reference (strict pointer) to instance of Foo Foo* baz; // baz is a pointer to reference to instance of Foo - In C++, classes and structs are pretty much the same. In D, the "class" keyword declares what is called class in C++, and D "struct" has the abilities of C (not C++) structure. - C++ program can be divided into parts by writing several .cpp files, and providing an interface header .h file for each; this mechanism relies on preprocessor to #include interface files. Namespaces are separately provided by the namespace statement. D divides programs into modules, each .d file is a separate module with its own namespace; you import modules with the import directive, and there is no need for separate interface files. - C++ requires global types, constants, variables, functions to be declared before they are used, and introduces a special syntax to provide forward references. In D you can use function declared in your module from any point of that module: /* C++ */ void bar(); // forward declaration needed void foo() { bar(); } void bar() { foo(); } /* D */ void foo() { bar(); } // bar() is already visible! void bar() { foo(); } - In C++, class members are private by default. In D, they are public by default. Also, you cannot use the public/private/protected specifier when inheriting from base class - it's always public: /* C++ */ class Foo: public Bar { ... } /* D */ class Foo: Bar { ... } - In C++, bodies of member functions can be defined outside class definition, and it is the prefferd way. This is not possible (nor it is needed) in D: /* C++ */ class Foo { void bar(); } void Foo::bar() { ... } /* D */ class Foo { void bar() { ... } } - C++ has three distinct resolution operators: "." (direct member access), "->" (indirect member access), and "::" (static member access). C++ also uses "::" to access member of the base class, or namespace. These all are replaced by a single "." in D, and compiler determines the exact meaning depending on the context: /* C++ */ struct Foo { int n; } Foo bar; Foo* baz; bar.n = 1; baz->n = 1; /* D */ struct Foo { int n; } Foo bar; Foo* baz; bar.n = 1; baz.n = 1; - Constructor/destructor semantics are different: /* C++ */ class Foo { Foo() { ... } // constructor ~Foo() { ... } // destructor } /* D */ class Foo { this() { ... } // constructor ~this() { ... } // destructor } - To call methods of base class, you use the pseudo-variable "super": /* C++ */ class Foo { public: void baz() { ... } } class Bar: public Foo { public: void baz() { Foo::baz(); /* call version of base class */ } } /* D */ class Foo { void baz() { ... } } class Bar: Foo { void baz() { super.baz(); /* call version of base class */ } } - In C++, you have to call constructor of the base class (or it is done for you implicitly) at the beginning of your constructor using a weird syntax. Also, you cannot call one constructor of your class from another in that class. In D, constructors are just functions, and are called as such: /* C++ */ class Foo { public: Foo() { default_ctor(); } Foo(int n) { default_ctor(); ... } private: void default_ctor() { /* does what needs to be done in any case */ } } class Bar: public Foo { public: Bar(int n): Foo(n) { ... } } /* D */ class Foo { this() { /* does what needs to be done in any case */ } this(int n) { this(); ... } } class Bar: Foo { this(int n) { super(n); ... } } - D syntax for array and pointer declarations is a bit different from C++ one: /* C++ */ int foo, bar[5]; // foo is int, bar is array of ints int* foo, bar; // foo is pointer to int, bar is int /* D */ int[5] foo, bar; // both foo and bar are arrays of ints int* foo, bar; // both foo and bar are pointers to int - D types are a bit different from those of C++. Here's the equivalence table for a typical Win32 C++ compiler: D -> 32-bit C++ char -> char byte -> signed char ubyte -> unsigned char short -> signed short ushort -> unsigned short int -> signed int, signed long uint -> unsigned int, unsigned long long -> N/A (64-bit signed int, signed long long in GCC) ulong -> N/A (64-bit unsigned int, unsigned long long in GCC) float -> float double -> double extended -> long double complex -> std::complex imaginary -> N/A - D provides built-in dynamic arrays, with functionality similar to the one provided by std::vector class from C++ STL; the syntax is much simpler, however: /* C++ */ vector<int> foo; // dynamic arrays of ints foo.push_back(1); // append 1 to the end of the array foo[0] = 2; // element access // iteration for (int i = 0; i < foo.size(); i++) foo[i] = 666; /* D++ */ int[] foo; // dynamic array of ints foo ~= 1; // append 1 to the end of the arrat foo[0] = 2; // element access // iteration for (int i = 0; i < foo.length; i++) foo[i] = 666; - Strings are represented by dynamic arrays of chars, rather than by pointers to null-terminated char sequences or std::string C++ STL class: /* C++ */ string foo, bar, baz; foo = "Hello, "; bar = "world!"; baz = foo + bar; // concatenate with + baz += "\n"; // append with += /* D */ char[] foo, bar, baz; foo = "Hello, "; bar = "world!"; baz = foo ~ bar; // concatenate with ~ baz ~= "\n"; // append with ~= - Everything is garbage-collected. That is, everything allocated by operator new, be it an object or a dynamic array, gets freed automatically, you don't have to use operator delete. This allows you to write code that is unsafe (and thus considered "bad") in C++, but perfectly legal in D: /* bad C++, but legal D */ int* foo(int n) { int* result; result = new int[n]; return result; } void main() { int* array = foo(5); ... return 0; // forgot to delete array! OK in D, bad thing in C++ } Oh, damn, I've tired of typing. =) There are SO many differences... I haven't mentioned array slicing, design by contract (the "Contracts" section in the D reference is a MUST READ!), interfaces, type complex, standard library, and many other things. Once again, the best idea is to read the entire D reference document, everything's there...
Mar 05 2002
parent "Pavel Minayev" <evilone omen.ru> writes:
Woah, it was a large one. I should probably have copyrighted it =)
But now it's too late... so enjoy it for free =)
Mar 05 2002