C++ IDE Funktionen wie in Netbeans?



  • Brauch ich nicht, ich mache keine Fehler 🕶 👍



  • Chefsoftwareentwickler schrieb:

    Brauch ich nicht, ich mache keine Fehler 🕶 👍

    Fehlererkennung vorziehen ist der Witz. Je früher desto besser. Also zum Beispiel ist jeder Fehler, den ein Kunde entdeckt, viel teurer als ein Fehler, den man noch im Haus entdeckt. Klassenbenamsung nebst Zweckentdeckung ist ganz früh und gehört recht gründlich gemacht. Daß man die Benamsung in anderen Sprachen gerne verschiebt, ist die eine Sache. Die andere tötet.



  • Was soll denn bitte an der Erkennung von Namensersetzung für Inkludedateien, Klassen, Parametern und Membern für das Refaktoring schwierig sein? Muss der Compiler nicht eh eine Syntaktische Analyse vornehmen und ist nicht dieser Teil, der leicht vom Compiler schreiben ist und der schwierige Teil sind dann die Optimierungen? Jeder Debugger ist doch in der Lage die Namen zu erkennen, da müssen sie doch auch ersetzbar sein mit einem Klick. Wenn was nicht aufgelöst werden kann, dann kann man immer noch warnen und abbrechen. Kann ja auch sein, dass ich die Compiler-Technik völlig falsch verstanden habe.

    Und was nicht eingebaut ist, als "brauche ich selten" zu verkaufen, finde ich fast so schlimm wie Bugs als Features zu verhökern. Alles was mir Arbeit abnimmt und nicht meine vollen Konzentration abverlangt, wie das manuelle Suchen und Ersetzen projektübergreifend, ist mir willkommen. Ich bin halt nicht so gut darin, im Vorfeld schon die ganze Struktur meines Endproduktes zu planen, einschließlich der Namen. Bei mir wächst das alles während des Entwickelns und da kann sich dann auch mal Neues auftun, an was ich überhaupt nicht gedacht hatte und dann hilft es wenn ich ganz leicht umstrukturieren kann, ohne dass ich da Angst haben muss mein Projekt zu zerschießen. Eine Klasse kann ich auch mal aufsplitten und dann macht der ursprüngliche Name keinen Sinn mehr usw.


  • Mod

    IDE-Searcher schrieb:

    eine Syntaktische Analyse vornehmen und ist nicht dieser Teil, der leicht vom Compiler schreiben ist und der schwierige Teil sind dann die Optimierungen?

    Nein.



  • IDE-Searcher schrieb:

    Was soll denn bitte an der Erkennung von Namensersetzung für Inkludedateien, Klassen, Parametern und Membern für das Refaktoring schwierig sein?

    In C++ ist alles so unglaublich vom Kontext abhängig. Bräuchtest in der IDE mindestens einen vollständigen C++-Compiler.

    IDE-Searcher schrieb:

    Und was nicht eingebaut ist, als "brauche ich selten" zu verkaufen, finde ich fast so schlimm wie Bugs als Features zu verhökern. Alles was mir Arbeit abnimmt und nicht meine vollen Konzentration abverlangt, wie das manuelle Suchen und Ersetzen projektübergreifend, ist mir willkommen.

    Ach, wirklich stören würde mich das nicht, wenns nicht gerade bei den normalen Menupunkten wäre, sondern im eigenen Menupunkt "Refacroring", wo es nicht nervt. Ist weniger verkaufen denn kapitulieren.

    IDE-Searcher schrieb:

    Ich bin halt nicht so gut darin, im Vorfeld schon die ganze Struktur meines Endproduktes zu planen, einschließlich der Namen.

    Das ist keiner. Zu erleben, wie man mehr Planungsweitsicht gewinnt, ist mit das geilste Gefühl beim fortgeschrittenen Programmierernlernen überhaupt. Das erste mal, wenn man vor einer Wahl steht und einfach weiß, daß von zwei Alternativen, die sich vorher völlig gleich anfühlten, daß eine davon in 3 Monaten das Projekt umkippen wird: Hammer!

    Und ab dann haste auch kaum noch Namensänderungsbedarf außer für lokale Variablen.

    IDE-Searcher schrieb:

    Bei mir wächst das alles während des Entwickelns und da kann sich dann auch mal Neues auftun, an was ich überhaupt nicht gedacht hatte und dann hilft es wenn ich ganz leicht umstrukturieren kann, ohne dass ich da Angst haben muss mein Projekt zu zerschießen.

    Zerschießen passierte mir dadurch niemals! Einfach den Namen ändern und die paar Auftritte des Namens ändern, alle 3-4 Änerungen neucompilieren, was hindert einen, damit 30 Änderungen pro Minute zu packen? Und erzähl mir nicht, Du würdest noch Namen ändern, die bereits deutlich häufiger benutzt werden.



  • Auf der einen Seite ist die Namensersetzung zu kompliziert, aber auf der anderen Seite kann man dies mit jeder Suchen&Ersetzen Funktion machen? Das verstehe ich nicht.



  • IDESearcher schrieb:

    Auf der einen Seite ist die Namensersetzung zu kompliziert, aber auf der anderen Seite kann man dies mit jeder Suchen&Ersetzen Funktion machen? Das verstehe ich nicht.

    Ich redete NICHT von Suchen&Ersetzen, sondern vom Jagen von Compilerfehlermeldungen.



  • IDESearcher schrieb:

    Auf der einen Seite ist die Namensersetzung zu kompliziert, aber auf der anderen Seite kann man dies mit jeder Suchen&Ersetzen Funktion machen? Das verstehe ich nicht.

    Nein, man kann das nicht mit Suchen&Ersetzen machen.
    Man muss Suchen&Ersetzen starten und für jedes Vorkommen entscheiden, ob das dazugehört - in einigen Fällen.



  • Also der Qt-Creator hat die Funktion drin, dass man einfach eine Klasse oder auch ein Member umbenennt und allen Stellen, die diesen Namen nutzen, werden automatisch umbenannt, da muss man nichts mehr von Hand prüfen. Man kann sich natürlich vorher die Änderungen nochmals anschauen und es wird auch gezeigt welche Änderungen an welchen Dateien vorgenommen würden.

    Ist anscheinend genau so eine unbekannte Funktion wie dass man sich auch im Qt-Creator den erzeugten Assemblercode beim Debuggen anschauen kann. Es ist interessant den Unterschied von MinGW32 und Clang64 zu sehen.

    Ich wusste bis jetzt auch noch nicht, dass ein statisches Array im Zugriff nur einen Assemblerbefehl braucht, ein Array mit new angelegt braucht zwei Befehle und ein Zugriff auf STL-Vector benötigt ganze vier Befehle.



  • IDEFinder schrieb:

    Ich wusste bis jetzt auch noch nicht, dass ein statisches Array im Zugriff nur einen Assemblerbefehl braucht, ein Array mit new angelegt braucht zwei Befehle und ein Zugriff auf STL-Vector benötigt ganze vier Befehle.

    Das ist vermutlich auch den Jungs von GCC neu. Würde es an Deiner Stelle mal als Bugreport einsenden.



  • Naja, kann ja sein dass durch Optimierungen und im Release das anders wird, aber der Debugger spuckt erst einmal so was aus:

    #include <vector>
    
    int main()
    {
        int a1[3];
        int *a2 = new int[3];
        std::vector<int> a3(3);
    
        a1[0] = 0;
        a1[1] = 1;
    
        a2[0] = 0;
        a2[1] = 1;
    
        a3[0] = 0;
        a3[1] = 1;
    
        delete[] a2;
    
        return 0;
    }
    
    11 [1]	    a1[0] = 0;
    0x401663  <+0x0063>        c7 45 e0 00 00 00 00  movl   $0x0,-0x20(%ebp)
            12 [1]	    a1[1] = 1;
    0x40166a  <+0x006a>        c7 45 e4 01 00 00 00  movl   $0x1,-0x1c(%ebp)
    
            14 [1]	    a2[0] = 0;
    0x401671  <+0x0071>        8b 45 f4              mov    -0xc(%ebp),%eax
    0x401674  <+0x0074>        c7 00 00 00 00 00     movl   $0x0,(%eax)
            15 [1]	    a2[1] = 1;
    0x40167a  <+0x007a>        8b 45 f4              mov    -0xc(%ebp),%eax
    0x40167d  <+0x007d>        83 c0 04              add    $0x4,%eax
    0x401680  <+0x0080>        c7 00 01 00 00 00     movl   $0x1,(%eax)
    
            17 [1]	    a3[0] = 0;
    0x401686  <+0x0086>        8d 45 d4              lea    -0x2c(%ebp),%eax
    0x401689  <+0x0089>        c7 04 24 00 00 00 00  movl   $0x0,(%esp)
    0x401690  <+0x0090>        89 c1                 mov    %eax,%ecx
    0x401692  <+0x0092>        e8 11 17 00 00        call   0x402da8 <std::vector<int, std::allocator<int> >::operator[](unsigned int)>
    0x401697  <+0x0097>        83 ec 04              sub    $0x4,%esp
    0x40169a  <+0x009a>        c7 00 00 00 00 00     movl   $0x0,(%eax)
            18 [1]	    a3[1] = 1;
    0x4016a0  <+0x00a0>        8d 45 d4              lea    -0x2c(%ebp),%eax
    0x4016a3  <+0x00a3>        c7 04 24 01 00 00 00  movl   $0x1,(%esp)
    0x4016aa  <+0x00aa>        89 c1                 mov    %eax,%ecx
    0x4016ac  <+0x00ac>        e8 f7 16 00 00        call   0x402da8 <std::vector<int, std::allocator<int> >::operator[](unsigned int)>
    0x4016b1  <+0x00b1>        83 ec 04              sub    $0x4,%esp
    0x4016b4  <+0x00b4>        c7 00 01 00 00 00     movl   $0x1,(%eax)
    


  • IDEFinder schrieb:

    Naja, kann ja sein dass durch Optimierungen und im Release das anders wird, aber der Debugger spuckt erst einmal so was aus:

    Es zählt wirklich nur optimierter Code.


Anmelden zum Antworten