www.digitalmars.com         C & C++   DMDScript  

digitalmars.D - D newb

reply Tim H <thockin+d hockin.org> writes:
Hi, I am a D newbie.  Why does this program segfault?

import std.stdio;
import std.c.stdlib;

class Foo
{
        public int m_int = 0;
}

int
main(string[] args)
{
        Foo f;
        printf("foo %d\n", f.m_int);
        return EXIT_SUCCESS;
}
Aug 17 2008
next sibling parent reply BCS <ao pathlink.com> writes:
Reply to Tim,

 Hi, I am a D newbie.  Why does this program segfault?
 
 import std.stdio;
 import std.c.stdlib;
 class Foo
 {
 public int m_int = 0;
 }
 int
 main(string[] args)
 {
 Foo f;
 printf("foo %d\n", f.m_int);
 return EXIT_SUCCESS;
 }

The default value for any object Reference (f in this case) is null. create a new object to use (Foo f = new F();)
Aug 17 2008
parent reply Tim H <thockin+d hockin.org> writes:
BCS Wrote:

 Reply to Tim,
 
 Hi, I am a D newbie.  Why does this program segfault?
 
 import std.stdio;
 import std.c.stdlib;
 class Foo
 {
 public int m_int = 0;
 }
 int
 main(string[] args)
 {
 Foo f;
 printf("foo %d\n", f.m_int);
 return EXIT_SUCCESS;
 }

The default value for any object Reference (f in this case) is null. create a new object to use (Foo f = new F();)

Doh, can you guess what language I am coming from? :) Is there any way to do C++ style on-stack local object ?
Aug 17 2008
next sibling parent BCS <ao pathlink.com> writes:
Reply to Tim,

 BCS Wrote:
 
 Reply to Tim,
 
 Hi, I am a D newbie.  Why does this program segfault?
 
 import std.stdio;
 import std.c.stdlib;
 class Foo
 {
 public int m_int = 0;
 }
 int
 main(string[] args)
 {
 Foo f;
 printf("foo %d\n", f.m_int);
 return EXIT_SUCCESS;
 }

create a new object to use (Foo f = new F();)

Is there any way to do C++ style on-stack local object ?

"scope" look it up in the classes spec page (I have not used it myself)
Aug 17 2008
prev sibling next sibling parent reply Robert Fraser <fraserofthenight gmail.com> writes:
Tim H wrote:
 BCS Wrote:
 
 Reply to Tim,

 Hi, I am a D newbie.  Why does this program segfault?

 import std.stdio;
 import std.c.stdlib;
 class Foo
 {
 public int m_int = 0;
 }
 int
 main(string[] args)
 {
 Foo f;
 printf("foo %d\n", f.m_int);
 return EXIT_SUCCESS;
 }

a new object to use (Foo f = new F();)

Doh, can you guess what language I am coming from? :) Is there any way to do C++ style on-stack local object ?

scope Foo f = new Foo(); The "scope" keyword in the declaration says to the compiler "this will not escape the function" thus creating the data on the stack. "f" is still a reference type in this case, however (although it may not be implemented as a reference -- that's up o the compiler).
Aug 17 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Robert Fraser:
 scope Foo f = new Foo();
 
 The "scope" keyword in the declaration says to the compiler "this will 
 not escape the function" thus creating the data on the stack. "f" is 
 still a reference type in this case, however (although it may not be 
 implemented as a reference -- that's up o the compiler).

But the 'scope' works only in some situations, the original poster can take a look at the docs about 'scope'. My question: does the compiler raise a compilation error if the 'scope' keyword is used where the compiler can't actually allocate the class on the stack? (if not, then I think it may be better for the compiler to raise such error, avoiding the illusion of efficiency). Bye, bearophile
Aug 17 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"bearophile" wrote
 Robert Fraser:
 scope Foo f = new Foo();

 The "scope" keyword in the declaration says to the compiler "this will
 not escape the function" thus creating the data on the stack. "f" is
 still a reference type in this case, however (although it may not be
 implemented as a reference -- that's up o the compiler).

But the 'scope' works only in some situations, the original poster can take a look at the docs about 'scope'. My question: does the compiler raise a compilation error if the 'scope' keyword is used where the compiler can't actually allocate the class on the stack? (if not, then I think it may be better for the compiler to raise such error, avoiding the illusion of efficiency).

In what situations does it not work? As long as the class is not too large for the stack (which is very unlikely), it should be able to allocate. -Steve
Aug 17 2008
parent reply JAnderson <ask me.com> writes:
Steven Schveighoffer wrote:
 "bearophile" wrote
 Robert Fraser:
 scope Foo f = new Foo();

 The "scope" keyword in the declaration says to the compiler "this will
 not escape the function" thus creating the data on the stack. "f" is
 still a reference type in this case, however (although it may not be
 implemented as a reference -- that's up o the compiler).

take a look at the docs about 'scope'. My question: does the compiler raise a compilation error if the 'scope' keyword is used where the compiler can't actually allocate the class on the stack? (if not, then I think it may be better for the compiler to raise such error, avoiding the illusion of efficiency).

In what situations does it not work? As long as the class is not too large for the stack (which is very unlikely), it should be able to allocate. -Steve

If the class has a component sub-class the component may be heap allocated. I don't agree with making that an error though. -Joel
Aug 17 2008
next sibling parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"JAnderson" wrote
 Steven Schveighoffer wrote:
 "bearophile" wrote
 Robert Fraser:
 scope Foo f = new Foo();

 The "scope" keyword in the declaration says to the compiler "this will
 not escape the function" thus creating the data on the stack. "f" is
 still a reference type in this case, however (although it may not be
 implemented as a reference -- that's up o the compiler).

take a look at the docs about 'scope'. My question: does the compiler raise a compilation error if the 'scope' keyword is used where the compiler can't actually allocate the class on the stack? (if not, then I think it may be better for the compiler to raise such error, avoiding the illusion of efficiency).

In what situations does it not work? As long as the class is not too large for the stack (which is very unlikely), it should be able to allocate. -Steve

If the class has a component sub-class the component may be heap allocated. I don't agree with making that an error though.

If the class allocates anything dynamically, it would be heap allocated. I think there's no way around that. for instance, C++'s vector class can be stack allocated, but the elements will be heap allocated. However, a frequently asked-for enhancement is to allow scope members which could be allocated as part of the class' space (and therefore would be allocated on the stack in the case of a scope allocated class). -Steve
Aug 17 2008
prev sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Joel Anderson:
 bearophile:
 My question: does the compiler raise a compilation error if the 'scope' 
 keyword is used where the compiler can't actually allocate the class on 
 the stack? (if not, then I think it may be better for the compiler to 
 raise such error, avoiding the illusion of efficiency).


If the class has a component sub-class the component may be heap allocated. I don't agree with making that an error though.

May I ask you why you don't like that as an error? Generally I don't like undefined situations, if I add the 'scope' keyword I want the class to be stack-allocated, and I assume the compiler does that. Then the layout of the memory used by the code is different, and I can for example take care to avoid a stack overflow. If the compiler at compile time is able to tell me that the class can't be allocated on the stack, then I think the program has to not compile until I remove the 'scope' keyword there. This makes the code reflect what the program actually does. Bye, bearophile
Aug 18 2008
parent reply JAnderson <ask me.com> writes:
bearophile wrote:
 Joel Anderson:
 bearophile:
 My question: does the compiler raise a compilation error if the 'scope' 
 keyword is used where the compiler can't actually allocate the class on 
 the stack? (if not, then I think it may be better for the compiler to 
 raise such error, avoiding the illusion of efficiency).


allocated. I don't agree with making that an error though.

May I ask you why you don't like that as an error? Generally I don't like undefined situations, if I add the 'scope' keyword I want the class to be stack-allocated, and I assume the compiler does that. Then the layout of the memory used by the code is different, and I can for example take care to avoid a stack overflow. If the compiler at compile time is able to tell me that the class can't be allocated on the stack, then I think the program has to not compile until I remove the 'scope' keyword there. This makes the code reflect what the program actually does. Bye, bearophile

What I'm talking about is: class A { } class B { ... A a = new A(); // Heap Allocated ... }; ... scope B b = new B; //B is scope allocated but A is not Say your using someone else's class. You get latest and you using one of there classes with the word scope. They've decided to add something that is heap allocated. Now suddenly your code is not working because someone made a slight change to their interface. Of course you might not be responsible for either pieces of code. You might be using a template from lib A to iterate over some class in lib B. Anyway what ends up happening is the code becomes very un-generic. People have to create 2 versions of everything. I think the idea of having scope members is a good one. However if your using someone else class that has heap allocation you really have no choice. If you make this an error then your limiting that classes use. As to the class overflowing the stack size. I think if a class is so big that that the compiler automatically heap allocates it, then there's a lot of other issues with your code or your running on some platform where it works better that way. The compiler should do what it can to make sure your code runs, slow as it may be, without logical errors. I think you always want to tell the compiler what you want to do rather then how and let it decide the best approach. That way you get more portable code that is optimized for whatever system its going on. -Joel
Aug 18 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"JAnderson" wrote
 bearophile wrote:
 Joel Anderson:
 bearophile:
 My question: does the compiler raise a compilation error if the 
 'scope' keyword is used where the compiler can't actually allocate the 
 class on the stack? (if not, then I think it may be better for the 
 compiler to raise such error, avoiding the illusion of efficiency).


allocated. I don't agree with making that an error though.

May I ask you why you don't like that as an error? Generally I don't like undefined situations, if I add the 'scope' keyword I want the class to be stack-allocated, and I assume the compiler does that. Then the layout of the memory used by the code is different, and I can for example take care to avoid a stack overflow. If the compiler at compile time is able to tell me that the class can't be allocated on the stack, then I think the program has to not compile until I remove the 'scope' keyword there. This makes the code reflect what the program actually does. Bye, bearophile

What I'm talking about is: class A { } class B { ... A a = new A(); // Heap Allocated ... }; ... scope B b = new B; //B is scope allocated but A is not Say your using someone else's class. You get latest and you using one of there classes with the word scope. They've decided to add something that is heap allocated. Now suddenly your code is not working because someone made a slight change to their interface.

The compiler cannot know when a constructor will decide to heap-allocate. So it cannot predict whether the entire class will be stack-allocated. Once the constructor is called, you cannot extend the previous stack frame (without a lot of extra work), and even then, it cannot be sure that the calling function won't use that stack space later in the function. I think what you ask for is impossible to implement, and impossible to detect. -Steve
Aug 19 2008
parent JAnderson <ask me.com> writes:
Steven Schveighoffer wrote:
 "JAnderson" wrote
 bearophile wrote:
 Joel Anderson:
 bearophile:
 My question: does the compiler raise a compilation error if the 
 'scope' keyword is used where the compiler can't actually allocate the 
 class on the stack? (if not, then I think it may be better for the 
 compiler to raise such error, avoiding the illusion of efficiency).


allocated. I don't agree with making that an error though.

Generally I don't like undefined situations, if I add the 'scope' keyword I want the class to be stack-allocated, and I assume the compiler does that. Then the layout of the memory used by the code is different, and I can for example take care to avoid a stack overflow. If the compiler at compile time is able to tell me that the class can't be allocated on the stack, then I think the program has to not compile until I remove the 'scope' keyword there. This makes the code reflect what the program actually does. Bye, bearophile

class A { } class B { ... A a = new A(); // Heap Allocated ... }; ... scope B b = new B; //B is scope allocated but A is not Say your using someone else's class. You get latest and you using one of there classes with the word scope. They've decided to add something that is heap allocated. Now suddenly your code is not working because someone made a slight change to their interface.

The compiler cannot know when a constructor will decide to heap-allocate. So it cannot predict whether the entire class will be stack-allocated. Once the constructor is called, you cannot extend the previous stack frame (without a lot of extra work), and even then, it cannot be sure that the calling function won't use that stack space later in the function. I think what you ask for is impossible to implement, and impossible to detect. -Steve

I agree, however it could know weather members are likely to be heap allocated or not. However I don't think that should raise errors. -Joel
Aug 19 2008
prev sibling parent JAnderson <ask me.com> writes:
Tim H wrote:
 
 Doh, can you guess what language I am coming from? :)

This page might be helpful then: http://prowiki.org/wiki4d/wiki.cgi?ShortFrequentAnswers -Joel
Aug 17 2008
prev sibling parent reply bearophile <bearophileHUGS lycos.com> writes:
Tim H., others have already answered your main question. Regarding your code:

Add the list of names you want to use, importing just the names you need,
avoiding namespace pollution:
import std.c.stdlib: writefln;


         public int m_int = 0;

public int m_int; Because variables are initialized to .init by default (and there's a way to avoid that), and int.init is 0.
 int main(string[] args)

You can use this, because the return value is automatic: void main() To print writef/writefln is generally better, because typesafe (but it makes your executable fatter): writefln(foo %d", f.m_int); Bye, bearophile
Aug 17 2008
next sibling parent reply Tim H <thockin+d hockin.org> writes:
bearophile Wrote:


         public int m_int = 0;

public int m_int; Because variables are initialized to .init by default (and there's a way to avoid that), and int.init is 0.

So every variable is 0 initialized?
 int main(string[] args)

You can use this, because the return value is automatic: void main()

If I want to return a value other than 0, how do I do it?
 To print writef/writefln is generally better, because typesafe (but it makes
your executable fatter):
 writefln(foo %d", f.m_int);

What does that mean - to be typesafe? Can you give me a real example of where writef() is better than printf(). I'm looking for a good D tutorial. Something that would have all these answers. Can you recommend one? I've been writing C for a dozen years and C++ for a few, as well as other stuff here and there. Tim
Aug 17 2008
next sibling parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"Tim H" wrote
 bearophile Wrote:


         public int m_int = 0;

public int m_int; Because variables are initialized to .init by default (and there's a way to avoid that), and int.init is 0.

So every variable is 0 initialized?

No, every variable is initialized to a default. Most of the time, this is zero (or null). However, sometimes, it is not. For instance, floating point numbers are initialized to NaN. If you want to know the initial value, it is stored as the inherent 'init' property. So for example, all ints are initialized to int.init (unless you override that with an assignment).
 int main(string[] args)

You can use this, because the return value is automatic: void main()

If I want to return a value other than 0, how do I do it?

The way you originally had it. I think bearophile was saying that in your particular example, you don't need to use it, because you never return anything but zero (EXIT_SUCCESS).
 To print writef/writefln is generally better, because typesafe (but it 
 makes your executable fatter):
 writefln(foo %d", f.m_int);

What does that mean - to be typesafe? Can you give me a real example of where writef() is better than printf().

Sure, if you do: printf("foo %d\n", "hello"), you will get the pointer of hello as an integer. if you do writef("foo, %d\n", "hello"), you get a type exception (I think), because writef is passed the type of all its arguments. A better example: printf("foo %s\n", 0), which gives you a segfault. With writef, %s is a 'catch all'. It means, 'check the type of the argument to see how to print it', and in the case: writef("foo %s\n", 0), you will get a 0. Most of the other % types are for formatting, like if you wanted a certain precision floating point, or to 0-pad, etc. Most of the time, you can just use %s: writef("%s, %s is an int, %s is a float, %s is a long", "hi", 5, 4.3, 1000000000000);
 I'm looking for a good D tutorial.  Something that would have all these 
 answers.  Can you recommend one?  I've been writing C for a dozen years 
 and C++ for a few, as well as other stuff here and there.

As I only use Tango (http://www.dsource.org/projects/tango), I don't know of tutorials that uses Phobos, but I would imagine there should be something on the digitalmars site. There's plenty of tutorials and instruction (and a book in print) if you want to use Tango. -Steve
Aug 17 2008
parent bearophile <bearophileHUGS lycos.com> writes:
Steven Schveighoffer:

 The way you originally had it.  I think bearophile was saying that in your 
 particular example, you don't need to use it, because you never return 
 anything but zero (EXIT_SUCCESS).

This too works, even if it looks a bit strange: void main() { return 1 }
 Most of the time, you can just use %s:
 writef("%s, %s is an int, %s is a float, %s is a long", "hi", 5, 4.3, 
 1000000000000);

In some situations you can also just avoid using formatting: writef("The result is ", r0, " after ", n, " iterations."); But you have to be careful that the first string doesn't contain % for other purposes. To avoid that D 2.x has write/writeln (or you can use my better put/putr functions). (I think I now know enough of D that I may be able to start writing a "D best practices" web page). Bye, bearophile
Aug 18 2008
prev sibling next sibling parent Lutger <lutger.blijdestijn gmail.com> writes:
Tim H wrote:
... 
 I'm looking for a good D tutorial.  Something that would have all these
 answers.  Can you recommend one?  I've been writing C for a dozen years
 and C++ for a few, as well as other stuff here and there.
 
 Tim

There is one wiki which contains a lot of information (probably the most) and further links: http://prowiki.org/wiki4d/wiki.cgi It has a section about learning D, I'd recommend reading 'text in d'. Perhaps the sections about porting C and C++ to D are also worthwhile in your case, to see differences. Furthermore, the digitalmars site has lots of good documentation, not only the spec but the articles are good too. Some articles are specific for C++ users. The book about Tango is really mostly a book about D, so that's good too. There is a sample chapter you may find useful here: http://www.gamedev.net/reference/programming/features/DTangoCh2/
Aug 17 2008
prev sibling parent BLS <nanali nospam-wanadoo.fr> writes:
Tim H schrieb:

 I'm looking for a good D tutorial.  Something that would have all these
answers.  Can you recommend one?  I've been writing C for a dozen years and C++
for a few, as well as other stuff here and there.
 
 Tim

Porting C++ to D at: http://prowiki.org/wiki4d/wiki.cgi?PortingFromCxx HTH, Bjoern
Aug 18 2008
prev sibling parent Jesse Phillips <jessekphillips gmail.com> writes:
On Sun, 17 Aug 2008 20:09:19 -0400, bearophile wrote:

 Tim H., others have already answered your main question. Regarding your
 code:
 
 Add the list of names you want to use, importing just the names you
 need, avoiding namespace pollution: import std.c.stdlib: writefln;
 
 
         public int m_int = 0;

public int m_int; Because variables are initialized to .init by default (and there's a way to avoid that), and int.init is 0.
 int main(string[] args)

You can use this, because the return value is automatic: void main() To print writef/writefln is generally better, because typesafe (but it makes your executable fatter): writefln(foo %d", f.m_int); Bye, bearophile

http://www.dsource.org/ Most everything there is for D 1.0 many tutorials/examples written before its release and only for Phobos (which you are using), but still valid.
Aug 17 2008