Announcement

Collapse
No announcement yet.

Debuggen nicht überall möglich in Borland C++ Builder 2006

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Debuggen nicht überall möglich in Borland C++ Builder 2006

    Hi

    Ich entwickle neuerdings mit Borland C++ 2006 und bin auf folgende Merwürdigkeit gestossen. In gewissen Teilen meines Codes kann ich nicht Debuggen. Hier das Code-Snippet:

    class ClTestRect
    {
    public:
    TestCOORD left;
    TestCOORD top;
    TestCOORD right;
    TestCOORD bottom;
    public:
    ClTestRect()
    { left = right = top = bottom = 0;}
    ClTestRect( ClTestRect &Other)
    { left = Other.left; right = Other.right; top = Other.top; bottom = Other.bottom;}
    ClTestRect( TRect &Other)
    { left = Other.left; right = Other.right; top = Other.top; bottom = Other.bottom;}
    ClTestRect( TestCOORD Left, TestCOORD Top, TestCOORD Right, TestCOORD Bottom)
    {
    left = MINCOORD( Left, Right);
    right = MAXCOORD( Left, Right);
    top = MINCOORD( Top, Bottom);
    bottom= MAXCOORD( Top, Bottom);
    }
    ClTestRect( ClTestPoint &Pt1, ClTestPoint &Pt2)
    {
    left = MINCOORD( Pt1.x, Pt2.x);
    right = MAXCOORD( Pt1.x, Pt2.x);
    top = MINCOORD( Pt1.y, Pt2.y);
    bottom= MAXCOORD( Pt1.y, Pt2.y);
    }
    operator TRect()
    {
    TRect Tmp; Tmp.left = left; Tmp.top = top; Tmp.right = right; Tmp.bottom = bottom;
    return Tmp;
    }
    void Reset()
    { left = 0; top = 0; right = 0; bottom = 0;}
    // ensures that left is smaller than right and top is smaller than bottom
    void RealRect()
    {
    TestCOORD Tmp;
    if( left > right)
    {
    Tmp = right;
    right = left;
    left = Tmp;
    }
    if( top > bottom)
    {
    Tmp = bottom;
    bottom = top;
    top = Tmp;
    }
    }
    // Normalizes the rect to left = 0 and top = zero and returns Offset instead
    // left and top of the rectangle are added to Offset; so if there is no preset offset
    // make sure, that Offset is zero before the call
    void NormalizeRectAndOffset( ClTestPoint &Offset)
    {
    RealRect();
    Offset.x += left;
    Offset.y += top;
    right = right - left;
    bottom = bottom - top;
    left = 0;
    top = 0;
    }
    inline bool IsEmpty( void)
    {
    return( (left == right) && (top == bottom));
    };
    // Adds DX and DY to this
    void OffsetRect( TestCOORD DX, TestCOORD DY)
    {
    left += DX;
    right += DX;
    top += DY;
    bottom += DY;
    }
    // Adds DPoint to this
    void OffsetRect( ClTestPoint DPoint)
    {
    left += DPoint.x;
    right += DPoint.x;
    top += DPoint.y;
    bottom += DPoint.y;
    }
    // Dehnt das Rechteck um DX und DY aus in allen Koordinaten
    void InflateRect( TestCOORD DX, TestCOORD DY)
    {
    left -= DX;
    right += DX;
    top -= DY;
    bottom += DY;
    }
    bool PointInRect( ClTestPoint &P)
    {
    if( (P.x >= left) && (P.x <= right) && (P.y >= top) && (P.y <= bottom))
    return true;
    return false;
    }
    // Widens the rect so that P is within the rect
    void Widen( ClTestPoint &P)
    {
    if( P.x < left)
    left = P.x;
    if( P.x > right)
    right = P.x;
    if( P.y < top)
    top = P.y;
    if( P.y > bottom)
    bottom = P.y;
    }
    // Multiplies left and right by ScaleX, top and bottom by ScaleY
    void Scale( TestCOORD ScaleX, TestCOORD ScaleY)
    {
    left *= ScaleX; right *= ScaleX;
    top *= ScaleY; bottom *= ScaleY;
    }
    // Bildet das Verbundrechteck aus den eigenen Koordinaten und denen von
    // R und überschreibt damit die eigenen Koordinaten.
    // Diese Fkt. ist sicher sinnvoller als UnionRect!
    void SelfUnionRect( ClTestRect &R)
    {
    if( IsEmpty() && (left == 0))
    { // šbernehme die Koordinaten von R
    left = R.left;
    right = R.right;
    top = R.top;
    bottom = R.bottom;
    return;
    }
    if( R.IsEmpty() && (R.left == 0))
    { // behalte die eigenen Koordinaten
    return;
    }
    left = MINCOORD( left, R.left);
    right = MAXCOORD( right, R.right);
    top = MINCOORD( top, R.top);
    bottom = MAXCOORD( bottom, R.bottom);
    }
    // Ende Fkt.
    void ToTRect( TRect &Rect)
    {
    Rect.left = left; Rect.right = right; Rect.top = top; Rect.bottom = bottom;
    }
    TestCOORD Width()
    { return (right - left) + 1;}
    TestCOORD Height()
    { return (bottom - top) + 1;}
    };




    In den fetten Methoden kann ich debuggen, überall sonst nicht. Warum ist das so? Zuerst habe ich gedacht, es könnte damit zu tun haben, dass der Compiler gewisse Methoden expandiert (da soweit ich weiss Methoden in der Klassdefinition implizit inline Methoden sind), aber gemäss meinen Compilereinstellungen sollten alle inline Funktionen expandiert werden. Ich habe keine Ahnung warum dies nicht funktioniert. Kann mir jemand helfen?

    PS: ich bin darauf gestossen, weil ich merkwürdige Floating Point Exceptions habe, evtl. gibt es einen Zusammenhang.

  • #2
    Es gibt ein extra C++Builder Forum hier......


    Auch alle Optimierungen ausgeschaltet?

    Und was heisst "nicht debuggen können"??

    Kein Breakpoint setzen? bleibt er nicht stehen?

    Letzteres deutet auf die eingeschalteten Optimierungen hin.

    Des Weiteren sollte man beim Umschalten zwischen DebugBuild und ReleaseBuild immer das ganze Projekt neu erzeugen lassen.

    Warum werden alle Funktionen innerhalb der Klasse als inline definiert? Ist m.E. nicht notwendig und - für meine Begriffe - extrem unübersichtlich. Warum mehrere public Abschnitte?
    Christian

    Comment


    • #3
      Hi

      Besten Danke für deine Antwort

      Hier die Klarstellungen:

      - ja, nicht debuggen können heisst in erster Linie keine Breakpoints setzen können. Allerdings kann ich auch nicht in die entsprechenden Methoden reindebuggen.
      - ich dachte alle Methoden sind inline wenn sie innerhalb der Klasse definiert sind. Zumindest gemäss folgendem Buch: C++ Programmierhandbuch, ISBN 978-3-939084-50-1. Oder hab ich was falsch verstanden?
      - Habe alle Optimierungen ausgeschaltet -> Menupunkt: Optimizations-> disable all optimisations. Habe ebenfalls mehrmals die ganze Applikation neu gebuilded.
      - mehrere public Abschnitte. Ja ich denke du hast recht, ist allerdings nicht mein Code. Hab ihn nur übernommen (übernehmen müssen)

      Gibt es evtl. noch andere Compilereinstellungen die einen Einfluss haben könnten?

      Gruss und Danki

      Comment


      • #4
        Hi,

        also
        1.) Nicht überall wo Inline drauf steht, muss auch nline drin sein !
        Das entscheidet letztendlich der Compiler, selbst wenn eine Methode implizit mit Inline definiert wurde.
        2.) Das dürfte aber mit Deinem Problem nichts zu tun haben
        3.) Lache jetzt nicht, wenn ich Dich frage ob Du denn alle Methoden aufrufts, die Du debguggen möchtest ?
        Sehe ich z.B. den default constructor in Deinem Bsp. wird dieser sicherlich aufgerufen. Ob der copy constructor, der in Deinem Bsp. grau ist aufgerufen wird, ist sicherlich zu bezweifeln. In solchen Fällen wird der Code vom Compiler gnadenlos weg optimiert .
        Sollte ich mit meiner Vermutung voll daneben liegen, bitte ich dieses zu entschuldigen, aber für mich sieht es an Hand Deiner Beschreibung einfach so auf.

        Gruß

        Gerhard

        Comment


        • #5
          Fazinierend, ich will etwas debuggen, aber nutze den Code dafür gar nicht......
          Christian

          Comment


          • #6
            Ja Christian,

            ich habe, wie Du auch, schon viel erlebt. So oft, wird z.B. ein Copy Constructor sicherlich nicht aufgerufen, oder ?

            Gruß
            Gerhard

            Comment


            • #7
              nööö, ist richtig
              Christian

              Comment

              Working...
              X