www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - Scope operator like in C++?

reply TimK <qwesxrfvzgb web.de> writes:
Hi!

I have a little (private) project in C++ and was thinking that I should give D
a chance (especially since it's not exactly new).

So I have a class TPerson where the declaration is in the header file and the
definition in the cpp-source file. Naturally a defined function looks
something like this:

void TCharacter::DoSomething(int x){...}

I do this for several reasons:
- The class would get really awkward to read through and understand, with all
the code in it - so I usually just put the declaration and the documentation
for public functions into it.
- a programmer who just wants to understand the class doesn't care about the
implementation.

Now I tried to make a class in D, too, following this style.
Unfortunately that doesn't work and I couldn't find a working alternative in
the documentation.

Is this not possible in D?
(I'm using GDC, so I guess it's still D 1.0)


Regards,
Tim
Mar 23 2010
next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 23 Mar 2010 06:41:36 -0400, TimK <qwesxrfvzgb web.de> wrote:

 Hi!

 I have a little (private) project in C++ and was thinking that I should  
 give D
 a chance (especially since it's not exactly new).

 So I have a class TPerson where the declaration is in the header file  
 and the
 definition in the cpp-source file. Naturally a defined function looks
 something like this:

 void TCharacter::DoSomething(int x){...}

 I do this for several reasons:
 - The class would get really awkward to read through and understand,  
 with all
 the code in it - so I usually just put the declaration and the  
 documentation
 for public functions into it.
 - a programmer who just wants to understand the class doesn't care about  
 the
 implementation.

 Now I tried to make a class in D, too, following this style.
 Unfortunately that doesn't work and I couldn't find a working  
 alternative in
 the documentation.

 Is this not possible in D?
 (I'm using GDC, so I guess it's still D 1.0)

First, welcome! Second, GDC is horrifically old. I'd recommend switching to ldc or the latest dmd 1. Third, yes, it is somewhat possible. But you have to think about it a different way. When defining a class' implementation, you define everything inside the class. This means that instead of this: void TCharacter::DoSomething(int x){...} int TCharacter::SomeOtherFunction() {...} you do this: class TCharacter { void DoSomething(int x){...} int SomeOtherFunction(){...} } It actually turns out to be less code to write because you don't have to repeat the class name over and over, and it reads better IMO to someone trying to understand the implementation. If you want to provide a "header file" for this, you may do so with a di file (d interface). This file can have simply prototypes and documentation. It will look exactly like your class definition, but does not need to contain your implementations. In my example, the di file looks like this: class TCharacter { /** * Docs for DoSomething */ void DoSomething(int x); /** * Docs for SomeOtherFunction() */ int SomeOtherFunction(); } The drawbacks of doing it this way are 1) you have to maintain two files instead of one, with almost identical contents and 2) di files without function implementations are not inlinable. Note also, template functions must be included in the interface file, because the source must always be available to the compiler. After explaining all that, and with my past experience with C++, I'd recommend *NOT* to do this. The D compiler has a builtin documentation generator, so someone trying to use your functions will want to turn to that instead (much easier to read), and maintenance on two files that have to always be in sync is sucky to say the least. The D compiler can auto-generate header files, but it is for the compiler's benefit, not a person's. All docs are stripped out, and indentations are removed. In addition, it tries to include implementations for functions which it thinks might be inlined. For an example of what really good generated docs look like, see tango's docs: http://www.dsource.org/projects/tango/docs/current My recommendation is to simply build your code inline, just like Java and C#, and use the doc generation tools to document your functions. It will take some getting used to, but I think you will appreciate the single-point-of-editing aspect of it. Good luck! -Steve
Mar 23 2010
parent TimK <qwesxrfvzgb web.de> writes:
== Quote from Steven Schveighoffer (schveiguy yahoo.com)'s article
 Second, GDC is horrifically old.  I'd recommend switching to ldc or the
 latest dmd 1.

Unfortunately I'm using Debian Stable 64 Bit right now and switching to either of those is out of the question (at least for now). Maybe I'll upgrade to Squeeze (and the LLVM compiler) soon. Anyway, thanks for the input, I'll keep that in mind if something won't work.
 The D compiler has a builtin documentation
 generator, so someone trying to use your functions will want to turn to
 that instead (much easier to read), and maintenance on two files that have
 to always be in sync is sucky to say the least.
 For an example of what really good generated docs look like, see tango's
 docs: http://www.dsource.org/projects/tango/docs/current
 My recommendation is to simply build your code inline, just like Java and
 C#, and use the doc generation tools to document your functions.  It will
 take some getting used to, but I think you will appreciate the
 single-point-of-editing aspect of it.

Oh, I didn't know that D had a builtin documentation generator... Well if the documentation will look like that then reading the class itself would become useless anyway. Guess I'll use that :) Thank you for your fast reply. Regards, Tim
Mar 23 2010
prev sibling next sibling parent bearophile <bearophileHUGS lycos.com> writes:
TimK:

 I have a little (private) project in C++ and was thinking that I should give D
 a chance (especially since it's not exactly new).

Welcome, and I suggest you to use D V.1 language still, because it's simpler to learn and its compilers have less bugs. The latest LDC and DMD are OK, I prefer LDC on Ubuntu and DMD on Windows, plus something to automate building (because the D1 compiler is not able to find modules by itself as Java does). Eventually D2 will be debugged and refined enough to be used by novices too. Hopefully it will not take too much time. You can of course play with D2 too (DMD only), but you can find some bugs.
 So I have a class TPerson where the declaration is in the header file and the
 definition in the cpp-source file. Naturally a defined function looks
 something like this:
 
 void TCharacter::DoSomething(int x){...}
 
 I do this for several reasons:
 - The class would get really awkward to read through and understand, with all
 the code in it - so I usually just put the declaration and the documentation
 for public functions into it.
 - a programmer who just wants to understand the class doesn't care about the
 implementation.
 
 Now I tried to make a class in D, too, following this style.
 Unfortunately that doesn't work and I couldn't find a working alternative in
 the documentation.
 
 Is this not possible in D?

Steven Schveighoffer has already told you most things. Generally when you change language it's better to use its specific idioms even if you don't like/understand them, because a well designed language is an organic thing, its parts are designed to be fit to each other. So what's bad and good is often language-specific. I've read people call D a Java++, or to define it a tidy C++, but in practice there are several differences between D and C++, for example the garbage collector changes many things. In D classes/structs have their methods written inside. The indentation helps the programmer see the grouping. In a module you can add related classes, if they aren't too much long. Bye, bearophile
Mar 23 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 23 Mar 2010 08:06:59 -0400, TimK <qwesxrfvzgb web.de> wrote:

 == Quote from Steven Schveighoffer (schveiguy yahoo.com)'s article
 Second, GDC is horrifically old.  I'd recommend switching to ldc or the
 latest dmd 1.

Unfortunately I'm using Debian Stable 64 Bit right now and switching to either of those is out of the question (at least for now). Maybe I'll upgrade to Squeeze (and the LLVM compiler) soon. Anyway, thanks for the input, I'll keep that in mind if something won't work.

I think the latest ldc is 64-bit. And there are a fair amount of people who use a 32-bit compiler on a 64-bit system, but I agree it's not savory.
 The D compiler has a builtin documentation
 generator, so someone trying to use your functions will want to turn to
 that instead (much easier to read), and maintenance on two files that  
 have
 to always be in sync is sucky to say the least.
 For an example of what really good generated docs look like, see tango's
 docs: http://www.dsource.org/projects/tango/docs/current
 My recommendation is to simply build your code inline, just like Java  
 and
 C#, and use the doc generation tools to document your functions.  It  
 will
 take some getting used to, but I think you will appreciate the
 single-point-of-editing aspect of it.

Oh, I didn't know that D had a builtin documentation generator... Well if the documentation will look like that then reading the class itself would become useless anyway. Guess I'll use that :)

Just a note, I think Tango uses dil (http://github.com/azizk/dil/ a D compiler written in D, not complete but the parser works) to generate the docs, so in order to make them look that good, you may have to do something similar. dmd also generates decent docs, I use it for dcollections along with candydoc. In general, I don't think there's any excuse to not use a doc generator :) -Steve
Mar 23 2010
prev sibling next sibling parent Trass3r <un known.com> writes:
 If you want to provide a "header file" for this, you may do so with a di  
 file (d interface).  [...]
 The drawbacks of doing it this way are 1) you have to maintain two files  
 instead of one, with almost identical contents

You forget the -H switch. http://www.digitalmars.com/d/2.0/dmd-linux.html#interface_files
Mar 23 2010
prev sibling next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
On Tue, 23 Mar 2010 10:08:08 -0400, Trass3r <un known.com> wrote:

 If you want to provide a "header file" for this, you may do so with a  
 di file (d interface).  [...]
 The drawbacks of doing it this way are 1) you have to maintain two  
 files instead of one, with almost identical contents

You forget the -H switch. http://www.digitalmars.com/d/2.0/dmd-linux.html#interface_files

No, I didn't. If you read my post, later I said that the compiler can do it for you, but it is not suitable for human consumption. The header file generated has lots of formatting removed, and no comments. It doesn't even always strip out the implementation. The OP's intention was to maintain the header file with just the prototypes and docs so a user of his code would not have the implementations in the way of the documentation. -Steve
Mar 23 2010
prev sibling parent Trass3r <un known.com> writes:
 No, I didn't.  If you read my post, later I said that the compiler can  
 do it for you, but it is not suitable for human consumption.  The header  
 file generated has lots of formatting removed, and no comments.  It  
 doesn't even always strip out the implementation.  The OP's intention  
 was to maintain the header file with just the prototypes and docs so a  
 user of his code would not have the implementations in the way of the  
 documentation.

Ah indeed, missed that.
Mar 23 2010