hab da ein problem mit einem operator+ und finde den fehler nicht.
vielleicht kann mir jemand sagen was ich da falsch gemacht habe.

auto WINAPI WinMain(HINSTANCE, HINSTANCE, char*, int) -> int
{
   txl::rect r1(120,150,430, 550);
   txl::rect r2(120,150,430, 550);

   width(r1) += 20;
   width(r2) = width(r1) + 50; // hier wird der fehler angezeigt
   size(r1) = txl::rect(100,100);
   position(r2) = txl::point(0,0);
   position(r1, txl::rect::vertices::center) = txl::point(0,0);
   inflate(r1).margins(0,0,0,100);
   deflate(r2).margins(10,10);
   txl::point pp = vertex(r1).left_center();

   return 0;
};

hier die fehlermeldung:

1>...error C2666: "txl::operator +": 2 Überladungen haben ähnliche Konvertierungen
1>...note: kann "txl::point txl::operator +(txl::point &,const txl::distance &) noexcept" sein [bei der Verwendung der argumentbezogenen Suche gefunden]
1>...note: oder "txl::rect txl::operator +(txl::rect &,const txl::distance &) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
1>...note: oder "long txl::temporary_object::operator +(const txl::temporary_object::rect_width &,const long) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
1>...note: oder "long txl::temporary_object::operator +(const txl::temporary_object::rect_height &,const long) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
1>...note: bei Anpassung der Argumentliste "(txl::temporary_object::rect_width, int)"

der relevante source:

namespace txl
{

class point
{
   public:
      long x;
      long y;

      point(void) noexcept;
      point(long xy) noexcept;
      point(long tx, long ty) noexcept;
      point(const point &p) noexcept;
      point(point &&p) noexcept;
      ~point(void) noexcept;

      auto operator=(const point &p) noexcept -> point&;
      auto operator=(point &&p) noexcept -> point&;

      auto operator==(const point &p) const noexcept -> bool;
      auto operator!=(const point &p) const noexcept -> bool;
}; /* class point */

class rect
{
   public:
      long left;
      long top;
      long right;
      long bottom;

      enum struct vertices 
      {
         left_top             = 0x01 | 0x10,
         left_center          = 0x01 | 0x20,
         left_bottom          = 0x01 | 0x40,
         center_top           = 0x02 | 0x10,
         center_center        = 0x02 | 0x20,
         center               = center_center,
         center_bottom        = 0x02 | 0x40,
         right_top            = 0x04 | 0x10,
         right_center         = 0x04 | 0x20,
         right_bottom         = 0x04 | 0x40
      };

      rect(void) noexcept;
      rect(long value) noexcept;
      rect(long w, long h) noexcept;
      rect(const point &p, long w, long h) noexcept;
      rect(const point &lt, const point &rb) noexcept;
      rect(long l, long t, long r, long b) noexcept;
      rect(const rect &r) noexcept;
      rect(rect &&r) noexcept;
      ~rect(void) noexcept;

      auto operator=(const rect &r) noexcept -> rect&;
      auto operator=(rect &&r) noexcept -> rect&;

      auto operator==(const rect &r) const noexcept -> bool;
      auto operator!=(const rect &r) const noexcept -> bool;
}; /* class rect */

class distance
{
   public:
      long x;
      long y;

      distance(void) noexcept;
      distance(long xy) noexcept;
      distance(long tx, long ty) noexcept;
      distance(const distance &d) noexcept;
      distance(distance &&d) noexcept;
      ~distance(void) noexcept;

      auto operator=(const distance &d) noexcept -> distance&;
      auto operator=(distance &&d) noexcept -> distance&;

      auto operator==(const distance &d) const noexcept -> bool;
      auto operator!=(const distance &d) const noexcept -> bool;
}; /* class distance */

auto operator+(point &p, const distance &d) noexcept -> point;
auto operator+=(point &p, const distance &d) noexcept -> point&;
auto operator-(point &p, const distance &d) noexcept -> point;
auto operator-=(point &p, const distance &d) noexcept -> point&;

auto operator+(rect &r, const distance &d) noexcept -> rect;
auto operator+=(rect &r, const distance &d) noexcept -> rect&;
auto operator-(rect &r, const distance &d) noexcept -> rect;
auto operator-=(rect &r, const distance &d) noexcept -> rect&;

class rect_reference
{
   public:
      txl::rect ▭

      rect_reference(txl::rect &r) noexcept : rect(r)
      {
      }

      rect_reference(const rect_reference &r) noexcept : rect(r.rect)
      {
      }

      rect_reference(rect_reference&&) noexcept = delete;

      ~rect_reference(void) noexcept
      {
      }

      auto operator=(const rect_reference&) noexcept -> rect_reference& = delete;
      auto operator=(rect_reference&&) noexcept -> rect_reference& = delete;
}; /* class rect_reference */

namespace temporary_object
{

class rect_width : public txl::rect_reference
{
   public:
      using rect_reference::rect_reference;

      auto operator=(const rect_width &r) noexcept -> rect_width&
      {
         rect.right = rect.left + (r.rect.right - r.rect.left);
         return *this;
      }

      auto operator=(const long w) noexcept -> rect_width&
      {
         rect.right = rect.left + w;
         return *this;
      }

      operator long(void) const noexcept 
      {
         return rect.right - rect.left;
      }
}; /* class rect_width */

inline auto operator+(const rect_width &r, const long value) noexcept -> long
{
   return (r.rect.right - r.rect.left) + value;
}

inline auto operator-(const rect_width &r, const long value) noexcept -> long
{
   return (r.rect.right - r.rect.left) - value;
}

inline auto operator*(const rect_width &r, const long value) noexcept -> long
{
   return (r.rect.right - r.rect.left) * value;
}

inline auto operator/(const rect_width &r, const long value) noexcept -> long
{
   return (r.rect.right - r.rect.left) / value;
}

inline auto operator+=(const rect_width &r, const long value) noexcept -> const rect_width&
{
   r.rect.right += value;
   return r;
}

inline auto operator-=(const rect_width &r, const long value) noexcept -> const rect_width&
{
   r.rect.right -= value;
   return r;
}

} /* namespace temporary_object */

inline auto width(txl::rect &r) noexcept -> temporary_object::rect_width
{
   return temporary_object::rect_width(r);
}

} /* namespace txl */

das problem ist

width(r1) + 50;

die funktion width ist hier in zeile 189 deklariert.
es wird nur ein temporary_object::rect_width erstellt.
die klasse rect_width faengt in zeile 131 an.
der operator+(const rect_width &r, const long value) faengt in zeile 154 an. der gibt einen long zurueck. mehr wird da eigendlich nicht gemacht.

woher kommt da dann die fehlermeldung?

Meep Meep

Versuch mal 50L statt 50 .

Alles klar, wilhelm tell. das war ein meisterschuss. aber irgendwie bin ich jetzt nicht gescheiter als vorher
wie kommts dazu ?

Meep Meep

Dein Operator+ ist vielfach überladen. Keine einzige Überladung passt 100%, beispielsweise passt die von dir gewünschte Überladung nicht, weil 50 ein int ist, kein long. Also werden Konvertierungen der Argumente in Betracht gezogen. Doch bei deinen Klassen lässt sich so ziemlich alles in alles umwandeln und auch alles aus int konstruieren. Daher kommen lauter verschiedene Überladungen gleich gut in Frage. Die Fehlermeldung gibt dir eine Liste der Möglichkeiten, die gefunden wurden.

Wobei zu erwähnen wäre, dass der gezeigte Code offensichtlich gekürzt wurde, und den beschriebenen Fehler nicht zeigt. Also gut geraten

SeppJ schrieb:

Dein Operator+ ist vielfach überladen. Keine einzige Überladung passt 100%, beispielsweise passt die von dir gewünschte Überladung nicht, weil 50 ein int ist, kein long. Also werden Konvertierungen der Argumente in Betracht gezogen. Doch bei deinen Klassen lässt sich so ziemlich alles in alles umwandeln und auch alles aus int konstruieren. Daher kommen lauter verschiedene Überladungen gleich gut in Frage. Die Fehlermeldung gibt dir eine Liste der Möglichkeiten, die gefunden wurden.

Wobei zu erwähnen wäre, dass der gezeigte Code offensichtlich gekürzt wurde, und den beschriebenen Fehler nicht zeigt. Also gut geraten

Ja, das hat mich auch ein bisschen verwundert. Aber die Fehlermeldung ist sehr eindeutig und der Rest des Codes lässt vermuten, dass da noch viel mehr Umwandlungsoperatoren und/oder Überladungen vorhanden sind. Was natürlich die Frage aufwirft, warum alles in alles konvertierbar ist. Der Grund für solch ein Design ist doch gerade, damit man solche versehentlichen Konvertierungen (die ja Fehler sind, wenn man beispielsweise eine Höhe wie eine Breite behandelt) vom Compiler finden lassen kann. Wenn alles in (fast) alles andere konvertierbar ist, kann man auch gleich long für alles nehmen.

SeppJ schrieb:

Dein Operator+ ist vielfach überladen. Keine einzige Überladung passt 100%, beispielsweise passt die von dir gewünschte Überladung nicht, weil 50 ein int ist, kein long. Also werden Konvertierungen der Argumente in Betracht gezogen. Doch bei deinen Klassen lässt sich so ziemlich alles in alles umwandeln und auch alles aus int konstruieren. Daher kommen lauter verschiedene Überladungen gleich gut in Frage. Die Fehlermeldung gibt dir eine Liste der Möglichkeiten, die gefunden wurden.

Wobei zu erwähnen wäre, dass der gezeigte Code offensichtlich gekürzt wurde, und den beschriebenen Fehler nicht zeigt. Also gut geraten

doch doch. der gezeigte code sollte alles behinhalten was den fehler angeht.

Meep Meep

camper schrieb:

SeppJ schrieb:

Dein Operator+ ist vielfach überladen. Keine einzige Überladung passt 100%, beispielsweise passt die von dir gewünschte Überladung nicht, weil 50 ein int ist, kein long. Also werden Konvertierungen der Argumente in Betracht gezogen. Doch bei deinen Klassen lässt sich so ziemlich alles in alles umwandeln und auch alles aus int konstruieren. Daher kommen lauter verschiedene Überladungen gleich gut in Frage. Die Fehlermeldung gibt dir eine Liste der Möglichkeiten, die gefunden wurden.

Wobei zu erwähnen wäre, dass der gezeigte Code offensichtlich gekürzt wurde, und den beschriebenen Fehler nicht zeigt. Also gut geraten

doch doch. der gezeigte code sollte alles behinhalten was den fehler angeht.

Meep Meep

Jetzt habt ihr beide Recht

Laut strenger Standardauslegung kommen bei dem Code die beiden Überladungen
(const txl::temporary_object::rect_width&, long int)
und
(long int, int) (also eingebauter Operator)
in Frage. Das heißt, dieser Code compiliert nicht, aber ein gutmütiger Compiler (beispielsweise der GCC, der nur warnt) ignoriert eventuell die zweite Möglichkeit, weil sie schlecht passt.

Deine Fehlermeldung listet hingegen 4 verschiedenen Kandidaten auf (aber spricht von "2 Überladungen" ), von denen ich mir anhand des Codes nicht direkt erklären kann, wieso diese passen sollten, außer durch weitere, nicht gezeigte Konvertierungsoperatoren und/oder Überladungen. Eventuell macht dein Compiler komische Sachen oder du hast den Überblick verloren und relevante Überladungen/Konvertierungen gekürzt.

1>...error C2666: "txl::operator +": 2 Überladungen haben ähnliche Konvertierungen
[1] 1>...note: kann "txl::point txl::operator +(txl::point &,const txl::distance &) noexcept" sein [bei der Verwendung der argumentbezogenen Suche gefunden]
[2] 1>...note: oder "txl::rect txl::operator +(txl::rect &,const txl::distance &) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
[3] 1>...note: oder "long txl::temporary_object::operator +(const txl::temporary_object::rect_width &,const long) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
[4] 1>...note: oder "long txl::temporary_object::operator +(const txl::temporary_object::rect_height &,const long) noexcept" [bei der Verwendung der argumentbezogenen Suche gefunden]
[5] 1>...note: bei Anpassung der Argumentliste "(txl::temporary_object::rect_width, int)"

[1] zeile 91
[2] zeile 96
[3] zeile 154
[4] diesen code hab ich euch tatsaechlich unterschlagen. ist operator+ fuer rect_height. 1:1 das selbe wie der operator+ fuer rect_width [3]. gibt nur nen long zurueck.
[5] ist die kommentierte zeile in der WinMain

andere ueberladungen bzw konvertierungen hab ich nicht gemacht.
von rect_height sollte wirklich alles code da sein. und rect_height ist echt ne kopie von rect_width.
mir geht es nur nich in den kopf warum er sich da an den operator+ von rect_width und rect_height stoert. ich seh da keinen zusammenhang, wie er da hin kommt

mir geht es nur nich in den kopf warum er sich da an den operator+ von rect_width und rect_height stoert. ich seh da keinen zusammenhang, wie er da hin kommt

Moment, ist das nicht der Operator, den du möchtest? Wenn nicht, dann hast du mich genau so verwirrt wie den Compiler. Das ist jedenfalls der, der gewählt wird, wenn du meinem Tipp mit dem 50L folgst.

Meep Meep schrieb:

mir geht es nur nich in den kopf warum er sich da an den operator+ von rect_width und rect_height stoert. ich seh da keinen zusammenhang, wie er da hin kommt

Moment, ist das nicht der Operator, den du möchtest? Wenn nicht, dann hast du mich genau so verwirrt wie den Compiler. Das ist jedenfalls der, der gewählt wird, wenn du meinem Tipp mit dem 50L folgst.

ich meinte die beide zusammen. rect_height hat ja nichts mit rect_width zu tun.
in der WinMain hab ich:

width(r2) = width(r1) + 50;

ich droesel das mal so auf wie ich mir das vorstelle:
width(r2) gibt ein temporary_object::rect_width zurueck.
width(r1) ebenso.
hab ich also temporary_object::rect_width(r2) = temporary_object::rect_width(1) + 50;
fuer temporary_object::rect_width hab ich nen operator+ , der wiederrum einen long zurueck gibt.
ergibt: temporary_object::rect_width = operator+(temporary_object::rect_width(r1), 50) .
nachdem der operator+ einen long zurueck gibt, bleibt temporary_object::rect_width(r2) = long_value ueberig.

also woher das problem mit rect_height ? und die anderen operatoren [1] und [2] sind mir noch raetselhafter

also woher das problem mit rect_height ? und die anderen operatoren [1] und [2] sind mir noch raetselhafter

Ich kann, wie camper auch, die vollständige Fehlermeldung mit dem gezeigten Code nicht nachvollziehen. Zeigt der gekürzte Code bei dir wirklich noch die vollständige Meldung?

Die Meldung ist ja sowieso etwas merkwürdig, da erst gesagt wird, es gäbe 2 Möglichkeiten und dann werden 4 gelistet und die offensichtliche (long, int) ist nicht einmal dabei. Es wäre durchaus vorstellbar, dass dein Compiler da eine Falschmeldung abgibt.

Meep Meep schrieb:

also woher das problem mit rect_height ? und die anderen operatoren [1] und [2] sind mir noch raetselhafter

Ich kann, wie camper auch, die vollständige Fehlermeldung mit dem gezeigten Code nicht nachvollziehen. Zeigt der gekürzte Code bei dir wirklich noch die vollständige Meldung?

Die Meldung ist ja sowieso etwas merkwürdig, da erst gesagt wird, es gäbe 2 Möglichkeiten und dann werden 4 gelistet und die offensichtliche (long, int) ist nicht einmal dabei. Es wäre durchaus vorstellbar, dass dein Compiler da eine Falschmeldung abgibt.

ja es ist wirklich alles fabei.
das einzige was ich weg getan hab sind die pfadangaben der dateien. weil die fuer das problem irrelevant sind. sonst ist alles dabei.
verwende ueberigens die VS 2015 community.

warning: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
   width(r2) = width(r1) + 50; // hier wird der fehler angezeigt
                           ^
test.cc:155:17: note: candidate 1: long int txl::temporary_object::operator+(const txl::temporary_object::rect_width&, long int)
     inline auto operator+(const rect_width &r, const long value) noexcept -> lo
                 ^
test.cc:203:27: note: candidate 2: operator+(long int, int) <built-in>
   width(r2) = width(r1) + 50; // hier wird der fehler angezeigt

Und diese Meldung kann ich auch nachvollziehen. Aber die Regeln für Funktionsüberladungsauflösung sind ziemlich arkan, ich mag mich nicht aus dem Fenster lehnen und sagen, welche Compiler hier recht hat, jedenfalls nicht ohne vorher ein paar Stunden mein Regelverständnis aufzufrischen. Nachvollziehbar heißt schließlich nicht unbedingt das gleiche wie standardkonform.

ich denk mal das da wirklich was mit dem VC2015 schief laeuft.
ich werd morgen mal schauen ob ich ein reproduzierendes beispiel machen kann, das wesendlich kuerzer und lauffig ist.

danke dir erstmal

Meep Meep
PS laeuffaehig im sinne von das er wieder so eine falsche oder nichtnachvollziehende fehlermeldung bringt