Re: find_overload_match for constructor

[Weller <weller@bfw-online.de>]

[-- Attachment #1: Type: text/plain, Size: 1516 bytes --]

Still working on this problem. A full example would lool like the
attachment. A being the base class and B being the constant class.

Another option would be to do the calls manually. e.g.
A a1 = A (INT)
a1->i = 123

But it still presents the same issue. I need to find the correct
constructor which takes the type argument so its not really an
improvement.
Anyone got any ideas how this could be achieved?

Cheers,
Lennart Weller

On Fri, May 08, 2015 at 11:29:06AM +0200, Weller wrote:
> Hey everyone,
> 
> I'm currently stomped on how to call_function_by_hand for a constructor.
> Basically I have a class in C++ which wraps multiple native data types to
> the underlying base class like this:
> 
> class constant_t: public value_t
> { constant_t (int);
>   constant_t (double);
>   constant_t (const char *);
> }
> 
> Now when I have a command line like
> (gdb) p $testnr1 + 0.1
> I need the function call to the constructor of constant_t so that I can
> use the operator+ on the value_t of $testnr1.
> 
> I looked through the code and the only thing I could find which came
> close to this was the code used for the operator overload on C++ classes
> with find_overload_match but I can't quite figure out how I would call
> this in case of an overloaded constructor. Do I need to create an object
> of type constant_t with it being passed to **args and **objp? In that
> case how would I achieve that, as the the created object is kinda what I
> want in the first place.
> 
> Any help is appreciated,
> Lennart

[-- Attachment #2: simple.cpp --]
[-- Type: text/x-c++src, Size: 490 bytes --]

#include <string.h>

enum T {
  INT,
  DOUBLE,
  STRING
};

class A {
public:
  T t;
  int i;
  double d;
  char *s;

  A (enum T);
};

class B : public A {
public:
  B (int);
  B (double);
  B (const char *);
};

A::A (enum T t) {
  this->t = t;
}

B::B (int i) : A (INT) {
  this->i = i;
}

B::B (double d) : A (DOUBLE) {
  this->d = d;
}

B::B (const char *s) : A (STRING) {
  this->s = strdup (s);
}

int main () {
  A a1 = B (123);
  A a2 = B (1.23);
  A a3 = B ("foo");
  return 0;
}