www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - delegate bug?

reply "Jack Applegame" <japplegame gmail.com> writes:
This code:

import std.stdio;
class A {
   void func() { writeln("A"); }
}
class B : A {
   override void func() { writeln("B"); }
}
void main() {
   A a = new A;
   B b = new B;

   auto dg = &a.func;
   dg();

   dg.ptr = cast(void*)b;
   dg();
}

outputs:
A
A

but expected:
A
B
Nov 09 2012
next sibling parent "Jack Applegame" <japplegame gmail.com> writes:
Windows dmd 2.060
Nov 09 2012
prev sibling next sibling parent Jacob Carlborg <doob me.com> writes:
On 2012-11-09 14:36, Jack Applegame wrote:
 This code:

 import std.stdio;
 class A {
    void func() { writeln("A"); }
 }
 class B : A {
    override void func() { writeln("B"); }
 }
 void main() {
    A a = new A;
    B b = new B;

    auto dg = &a.func;
    dg();

    dg.ptr = cast(void*)b;
    dg();
 }

 outputs:
 A
 A

 but expected:
 A
 B

This is expected behavior. Delegates do not perform any dynamic dispatch. The method that is called is chosen when the delegate is created, i.e. "auto dg = &a.func;" You can workaround this by calling another method in "A" that will call the actual method you want to call, something like this: class A { void resolveVirtualCall () { func(); } } auto dg = &a.resolveVirtualCall; -- /Jacob Carlborg
Nov 09 2012
prev sibling next sibling parent reply Manfred Nowak <svv1999 hotmail.com> writes:
Jack Applegame wrote:

    dg.ptr = cast(void*)b;

This changes the environment only. It does not change the function called on the``dg()'-request---and the function called does not depend on the environment. But including a dependence on the environment may not change the output, because the compiler may instruct the executable to memoize the output. Hint: casting is equivalent to exclaiming: "I know what I am doing. Therefore: shut up compiler!" .manfred
Nov 09 2012
parent reply Manfred Nowak <svv1999 hotmail.com> writes:
Jack Applegame wrote:

 Ok. Then how to implement in D this С++ std::function feature?
 
 http://liveworkspace.org/code/01aa058901529f65cb9a3cc4ba605248

That feature is among others defined here: http://en.cppreference.com/w/cpp/utility/functional/function As one might see it is a template, defined in a library. Therefore the first question is, wether D has a similar template in a library---and secondly: without such a template in a library: how to implement the base functionality in a non-generic case. Because this is a learning group and not a teaching group--and you did not report on your fruitless tries: go on. -manfred
Nov 09 2012
next sibling parent reply =?UTF-8?B?QWxpIMOHZWhyZWxp?= <acehreli yahoo.com> writes:
On 11/09/2012 10:30 AM, Manfred Nowak wrote:
 Jack Applegame wrote:

 Ok. Then how to implement in D this С++ std::function feature?

 http://liveworkspace.org/code/01aa058901529f65cb9a3cc4ba605248

That feature is among others defined here: http://en.cppreference.com/w/cpp/utility/functional/function

The following D program produces the same output as the C++ example there: import std.stdio : writeln; import std.functional : curry; struct Foo { int num; void print_add(int i) { writeln(num + i); } } void print_num(int i) { writeln(i); } void main() { // store a free function auto f_display = &print_num; f_display(-9); // store a lambda auto f_display_42 = { print_num(42); }; f_display_42(); // store a curried call alias curry!(print_num, 31337) f_display_31337; f_display_31337(); // store a call to a member function auto f_add_display = (Foo foo, int i) { return foo.print_add(i); }; auto foo = Foo(314159); f_add_display(foo, 1); } D has more features: // store a call to a member function on a particular object auto f_print_add_on_object = &foo.print_add; f_print_add_on_object(2); There is also std.functional.toDelegate: http://dlang.org/phobos/std_functional.html#toDelegate Ali
Nov 09 2012
parent reply Timon Gehr <timon.gehr gmx.ch> writes:
On 11/09/2012 09:13 PM, Jack Applegame wrote:
 Ok. I will try to explain what exactly i need.

 ...

The following works. You can also use a (scoped) delegate in order to allow the caller to close over his context. import std.stdio; class Figure { void draw(){} void erase(){} } class Circle : Figure { override void draw() { writeln("drawing circle"); } override void erase() { writeln("erasing circle"); } } class Square : Figure { override void draw() { writeln("drawing square"); } override void erase() { writeln("erasing square"); } } class Triangle : Figure { override void draw() { writeln("drawing triangle"); } override void erase() { writeln("erasing triangle"); } } void main() { Figure[] figures; createFigures(figures); doAction(figures, x=>x.draw()); doAction(figures, x=>x.erase()); } void doAction(Figure[] figures, void function(Figure) action) { foreach(Figure figure; figures) { action(figure); } } void createFigures(ref Figure[] figures) { figures ~= new Circle; figures ~= new Square; figures ~= new Triangle; }
Nov 09 2012
next sibling parent Jacob Carlborg <doob me.com> writes:
On 2012-11-09 21:31, Jack Applegame wrote:

 Wow! Great! Thanks.
 But I can't understend this syntax:
 x=>x.draw()


 Where i can read about it?

It's a delegate literal, or also known as a lambda. http://dlang.org/expression.html#Lambda -- /Jacob Carlborg
Nov 09 2012
prev sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 11/09/2012 09:31 PM, Jack Applegame wrote:
 On Friday, 9 November 2012 at 20:22:40 UTC, Timon Gehr wrote:
 The following works. You can also use a (scoped) delegate in order to
 allow the caller to close over his context.

Wow! Great! Thanks. But I can't understend this syntax: x=>x.draw() Where i can read about it?

It is a lambda function literal. It is as if you did static void action(Figure x){ return x.draw(); } doAction(figures, &action); which can also be written in any of the following ways. Because the types are mandated by the function that is called, you can leave them out: doAction(figures, function void(Figure x){ return x.draw(); }); // function literal doAction(figures, function(x){ return x.draw(); }); // infer types doAction(figures, (x){ return x.draw(); }); // infer 'function' doAction(figures, (x)=>x.draw()); // convenient lambda syntax doAction(figures, x=>x.draw()); // also without parentheses It is documented here (scroll up a bit, Lambda does not seem to have an anchor) http://dlang.org/expression.html#FunctionLiteral In this case, we used the feature to implement a member function pointer, but there are many more applications that such a shorthand syntax makes convenient. It might generally be helpful for your programming skills to get accustomed to functional programming a bit. So in case you are interested, I suggest you consult your search engine of choice about the subject. You could eg. look into Scheme and/or Haskell and try to reproduce some of the examples also in D.
Nov 09 2012
prev sibling parent Timon Gehr <timon.gehr gmx.ch> writes:
On 11/09/2012 07:49 PM, Jack Applegame wrote:
 Because this is a learning group and not a teaching group--and you did
 not report on your fruitless tries: go on.

 -manfred

member-function by combining potinter to object and pointer to function: http://liveworkspace.org/code/1fe3107cf3a311aa95cb9fc62b9117a7 I have no idea how to do somethink like that in D.

auto memberFunctionPointer = function(X receiver, A arg0, B arg1, C arg2)=>receiver.memberFunction(arg0, arg1, arg2); This strategy is also the best way for a C++ compiler to implement a standard conformant member function pointer behind the scenes, so you lose nothing.
Nov 09 2012
prev sibling next sibling parent "Jack Applegame" <japplegame gmail.com> writes:
Ok. Then how to implement in D this С++ std::function feature?

http://liveworkspace.org/code/01aa058901529f65cb9a3cc4ba605248
Nov 09 2012
prev sibling next sibling parent "Jack Applegame" <japplegame gmail.com> writes:
 Because this is a learning group and not a teaching group--and 
 you did
 not report on your fruitless tries: go on.

 -manfred

member-function by combining potinter to object and pointer to function: http://liveworkspace.org/code/1fe3107cf3a311aa95cb9fc62b9117a7 I have no idea how to do somethink like that in D.
Nov 09 2012
prev sibling next sibling parent "Jack Applegame" <japplegame gmail.com> writes:
Ok. I will try to explain what exactly i need.

import std.stdio;

import std.stdio;

class Figure {
   void draw(){}
   void erase(){}
}

class Circle : Figure {
   override void draw() { writeln("drawing circle"); }
   override void erase() { writeln("erasing circle"); }
}

class Square : Figure {
   override void draw() { writeln("drawing square"); }
   override void erase() { writeln("erasing square"); }
}

class Triangle : Figure {
   override void draw() { writeln("drawing triangle"); }
   override void erase() { writeln("erasing triangle"); }
}

void main() {
   Figure[] figures;
   createFigures(figures);
   doAction(figures, &Figure.draw);
   doAction(figures, &Figure.erase);
}

void doAction(Figure[] figures, void function() action) {
   foreach(Figure figure; figures) {
     // how to do action with figure???
   }
}

void createFigures(ref Figure[] figures) {
   figures ~= new Circle;
   figures ~= new Square;
   figures ~= new Triangle;
}
Nov 09 2012
prev sibling next sibling parent "Jack Applegame" <japplegame gmail.com> writes:
On Friday, 9 November 2012 at 20:22:40 UTC, Timon Gehr wrote:
 The following works. You can also use a (scoped) delegate in 
 order to allow the caller to close over his context.

Wow! Great! Thanks. But I can't understend this syntax: x=>x.draw() Where i can read about it?
Nov 09 2012
prev sibling parent "Jack Applegame" <japplegame gmail.com> writes:
I have found it. This is shorthand lambda syntax.
Nov 09 2012