Was würdet ihr an C++ verbessern?

[dot]

SideWinder schrieb:

Wer einmal längere Zeit mit Eclipse gearbeitet hat (für Java) findet Visual Studio eigentlich nicht mehr sonderlich beeindruckend.

Da muss ich widersprechen. Wann immer ich zwangsweise mit Eclipse gearbeitet hab (was zugegeben noch nicht so oft war, aber jedesmal Java ist einmal zu oft wenn du mich fragst) war ich heilfroh wenn ich wieder eine vernünftige IDE verwenden konnte. Aber das ist wohl stark Geschmackssache...und abgesehen davon sollte man eine C++ IDE wenn dan mit einer anderen C++ IDE vergleichen

[SideWinder]

GPC schrieb:

SideWinder schrieb:

Wer einmal längere Zeit mit Eclipse gearbeitet hat (für Java) findet Visual Studio eigentlich nicht mehr sonderlich beeindruckend.

Visual Studio für C++ vielleicht. Im C#-Modus ist es richtig gut

Ja, das habe ich mittlerweile auch mitgekriegt. Es scheint einfach Probleme mit C++ als Sprache zu geben um eine wunderbare IDE zu erstellen (bzw. man will VAX nicht ins Geschäft pfuschen?).

Alleine das Project Property Sheet ist ja aus Usability-Sicht nicht zu fassen. Additional Dependencies für den Linker sind in einer sehr interessanten 90er-Box hinzuzufügen. Wenn man sich da das hinzufügen von Libraries in Eclipse ansieht oder "References" im C#-Mode...

Aber das soll ja ein Thread über C++ werden. Ich hör' dann mal auf

MfG SideWinder

[SideWinder]

Gibt es jetzt eigentlich für C++ irgendeine Art Maven-Package-System mit Dependency-Resolution?

MfG SideWinder

[Artchi]

SideWinder schrieb:

Gibt es jetzt eigentlich für C++ irgendeine Art Maven-Package-System mit Dependency-Resolution?

MfG SideWinder

Theoretisch jedes BSD/Linux Packaging. Kenne mich mit Linux nicht aus, aber unter FreeBSD ist das jedenfalls out-of-box dabei, mittels Makefiles. Das FreeBSD System löst die Abhängigkeiten auf, lädt notfalls fehlende (Source-)Libs von den Servern und baut das Projekt.

Wäre aber natürlich ein allgemeineres System nötig, das man z.B. auch mit dem Windows SDK nutzen könnte. Also in dem speziellen Fall nicht.

Eigentlich muß man ja die bestehen Tools wie bjam und SCons nur noch erweitern, weil die können ja schon Dependencies auflösen, nur halt noch nicht fehlende Libs von einem Server "besorgen". Aber auch das würde nicht alles lösen, weil du brauchst auch eine Community, die das pflegt. Und in Firmen muss sich da auch jemand drum kümmern. Mann kann hier höchstens der C++ Community einen Vorwurf machen, aber nicht der Sprache selbst.

Aber was hat das alles mit der C++ Sprache zu tun? Das sind alles nur entfernte Tools, die man für jede Sprache entwickeln kann. Finde die Diskussion ziemlich sinnlos, in diesem Thread, da es um C++ als Sprache geht.

[Artchi]

SideWinder schrieb:

Ja, das habe ich mittlerweile auch mitgekriegt. Es scheint einfach Probleme mit C++ als Sprache zu geben um eine wunderbare IDE zu erstellen (bzw. man will VAX nicht ins Geschäft pfuschen?).

Wieso Sprache? Mag sein, das dir VC nicht gefällt, aber das ist eine IDE und keine Sprache. Ganz davon abgesehen, das VAX beweist, das deine Aussage nicht auf C++ zutrifft. Wer zu geizig oder arm ist, 49 US$ für VAX auszugeben... hat Pech.

[SideWinder]

Ich meinte "Probleme bei Microsoft mit C++". Deswegen auch dann der Text in der Klammer. Möglich wäre es ja, aber offenbar tut man sich bei Microsoft weit weniger an um eine gute IDE für C++ zu erstellen als bspw. für C#.

MfG SideWinder

[dot]

SideWinder schrieb:

Möglich wäre es ja, aber offenbar tut man sich bei Microsoft weit weniger an um eine gute IDE für C++ zu erstellen als bspw. für C#.

http://channel9.msdn.com/Shows/Going+Deep/Craig-Symonds-and-Mohsen-Agsen-C-Renaissance

Abgesehen davon wirst du sicherlich nicht bestreiten dass z.B. der VC++ Debugger mit großem Abstand der Beste native Debugger ist dens gibt...

[Eisflamme]

Der Debugger soll mal Ausdrücke auswerten können und nicht ständig meckern und wenn ich einen Zeiger angebe und das ein Array ist, soll der das selbstständig kapieren und mir die Arraywerte und nicht nur den erste zurückgeben (oder man sollte das via Schlüsselwort oder [] hinter Variablennamen im Überwachungsfenster erzwingen können).

Aber geht ja nicht um MSVC++ hier

[dot]

Eisflamme schrieb:

Der Debugger soll mal Ausdrücke auswerten können und nicht ständig meckern und wenn ich einen Zeiger angebe und das ein Array ist, soll der das selbstständig kapieren und mir die Arraywerte und nicht nur den erste zurückgeben (oder man sollte das via Schlüsselwort oder [] hinter Variablennamen im Überwachungsfenster erzwingen können).

Das geht doch alles, es gibt afaik sogar ne Möglichkeit die Anzeige im Watch Window per Skript für deine eigenen Typen zu erweitern (wie das z.B. die die std Container gemacht ist)

[Ramsis]

off topic geworden.

Noch eine verbesserung ist mir eingefallen.

template<typename tDerived>
class Foo
{
    // implementation
};

class MyFoo : public Foo<MyFoo>
{
    // leer
};

// instance bilden

MyFoo my_instance;

//
// Es soll möglich sein das der Compiler
// die MyFoo Klasse automatisch definiert
//
// folgender masse

Foo<identity> my_instance; // das gleiche wie "MyFoo my_instance;"

// der Bezeichner identity ist ein möglicher Schlüsselwort(Keyword)
// my_instance ist eine variable von unbenannten Type(MyFoo) den der Compiler erstellt hat.

[Nexus]

Was soll das bringen, wenn Foo<identity> das gleiche wie MyFoo bedeutet? MyFoo ist ja nicht nur irgendeine Instanziierung des Foo -Templates, sondern eine davon abgeleitete Klasse.

Oder kannst du das etwas genauer erklären, am besten mit einem Anwendungsfall?

[Ramsis]

template<typename tDerived>
class Window
{
     Window(Window* parent, ...)
     {}

     void (tDerived::*onClick)();
};

// diese Klasse muss Du erstellen.
// die Klasse kannst du nicht als Basis Klasse verwenden
// sonst würde onClick member function pointer
// Probleme machen.
// diese Klasse ist nur für einen Zweck da um Objekte zu erstellen
class MyWindow : public Window<MyWindow>
{
     MyWindow(Window* parent, ...)
         : Window<MyWindow>(parent, ...)
     {}
};

// verwendung

int main()
{
    MyWindow obj;

   // oder so, was besser ist
   Window<identity> obj;
}

[Dravere]

Warum muss diese Klasse erstellt werden?
Warum kann man sie nicht als Basisklasse verwenden?
Warum würde OnClick Member-Function-Pointer Probleme machen?

Und inwiefern hilft nun dabei dieses Window<identity> , welches du bis jetzt nicht wirklich erklärt hast, was es machen soll.

Grüssli

[Ramsis]

Ich versuche es zu verdeutlichen.

class Window
{
     Window(Window* parent, ...)
     {}
};

template<typename tDerived>
class WindowImpl : public Window
{
     WindowImpl<tDerived>(Window* parent, ...) : Window(parent, ...)
     {}

     void (tDerived::*onClick)();
};

class MyWindow : public WindowImpl<MyWindow>
{
     MyWindow(Window* parent, ...)
         : WindowImpl<MyWindow>(parent, ...)
     {}
};

Dravere schrieb:

Warum muss diese Klasse erstellt werden?

Bedenke dass der template type parammeter von Klasse "WindowImpl", eine Abgeleitete Klasse sein muss.

Dravere schrieb:

Warum kann man sie nicht als Basisklasse verwenden?
Warum würde OnClick Member-Function-Pointer Probleme machen?

class FrameWindow : public MyWindow
{
     FrameWindow(Window* parent, ...) : Window(parent, ...)
     {
         // error type not compatibel
         onClick = &FrameWindow::this_Click;
     }

     // error uns fellt der template parammeter
     // wenn wir FrameWindow nehmen kommt es in der Abgeleiteten Klasse 
     // zu Fehlern siehe onClick
     void (???::*onDoubleClick)();

     void this_Click() {}
};

Dravere schrieb:

Und inwiefern hilft nun dabei dieses Window<identity> , welches du bis jetzt nicht wirklich erklärt hast, was es machen soll.

Grüssli

der Compiler soll uns die Fehlende Klasse definieren

class Window
{
     Window(Window* parent, ...)
     {}
};

template<typename tDerived>
class WindowImpl : public Window
{
     WindowImpl<tDerived>(Window* parent, ...) : Window(parent, ...)
     {}

     void (tDerived::*onClick)();
};

int main()
{
      WindowImpl<identity> win;
}

aus dem Oberen Quelltext erstellt uns der Compiler

class Window
{
     Window(Window* parent, ...)
     {}
};

template<typename tDerived>
class WindowImpl : public Window
{
     WindowImpl<tDerived>(Window* parent, ...) : Window(parent, ...)
     {}

     void (tDerived::*onClick)();
};

// achtung Compiler generierter Code
class unique_123456789 : public WindowImpl<unique_123456789>
{
     unique_123456789() : WindowImpl<unique_123456789>(Window* parent, ...)
     {}

};

int main()
{
      // unique_123456789 alias WindowImpl<identity>
      unique_123456789 win;
}

[Eisflamme]

dot schrieb:

Eisflamme schrieb:

Der Debugger soll mal Ausdrücke auswerten können und nicht ständig meckern und wenn ich einen Zeiger angebe und das ein Array ist, soll der das selbstständig kapieren und mir die Arraywerte und nicht nur den erste zurückgeben (oder man sollte das via Schlüsselwort oder [] hinter Variablennamen im Überwachungsfenster erzwingen können).

Das geht doch alles, es gibt afaik sogar ne Möglichkeit die Anzeige im Watch Window per Skript für deine eigenen Typen zu erweitern (wie das z.B. die die std Container gemacht ist)

Wie das geht?

Wenn in meinem Code irgendwo bla* steht und sich dahinter ein Array verbirgt und ich bla als überwachte Variable eingebe, dann gibt er mir nur den ersten Wert.

[Dravere]

@Ramsis,
Du redest wirres Zeug ...
Warum muss der Templateparemeter von WindowImpl eine abgeleitete Klasse sein? Das ist doch überhaupt gar nicht zwingend.

Meine beiden weiteren Fragen hast du mit dem Code auch nicht beantwortet. Ich habe nicht gefragt, wieso man einen Templateparameter braucht, sondern warum man sie nicht als Basisklasse verwenden kann wegen des Member-Function-Pointer.

Deine Aussagen sind irgendwie völlig zusammenhangslos. Ich weiss nicht mal was ich fragen soll, um da Licht ins Dunkle zu bringen, das ist so wirres Zeug. Vielleicht solltest du weiter ausholen, was du eigentlich machen möchtest. Vielleicht auch weniger Code hinschreiben dafür mehr Text und erklären, um was es dir geht.

Grüssli

[dot]

Eisflamme schrieb:

Wenn in meinem Code irgendwo bla* steht und sich dahinter ein Array verbirgt und ich bla als überwachte Variable eingebe, dann gibt er mir nur den ersten Wert.

Dann schreib mal bla,100 dann interpretiert er den Wert als Zeiger auf ein Array auf 100 Elementen

[Matzer]

Ramsis schrieb:

class FrameWindow : public MyWindow
{
     FrameWindow(Window* parent, ...) : Window(parent, ...)
     {
         // error type not compatibel
         onClick = &FrameWindow::this_Click;
     }

     // error uns fellt der template parammeter
     // wenn wir FrameWindow nehmen kommt es in der Abgeleiteten Klasse
     // zu Fehlern siehe onClick
     void (???::*onDoubleClick)();

     void this_Click() {}
};

Ich verstehe schon garnicht, warum du dich überhaupt auf irgendeinen Symbolnamen festnagelst:

class window{
    public:
    boost::signals::signal<void()> on_click_signal;
};

class my_window : public window{

    public:
    my_window(){
         this->on_click_signal.connect(boost::bind(my_window::on_click,this));    // oder so ähnlich ;)
    }

    void on_click(){
        // handle event
    }
};

Das erfüllt doch die gleichen Anforderungen wie der Kauderwelsch mit den abgeleiteten Klassen & Templateparametern oder?

[SeppJ]

Eine Kleinigkeit die noch nicht genannt wurde:
Kommentare im Stil von /* ... */ , aber schachtelbar. Der Ersatz durch ifdef ist derzeit einfach umständlich und einzelne Reihen sind manchmal eben einfach nicht genug.

[Matzer]

Moin,

ich habe gerade folgendes gefunden:

In C with Classes, it was possible to define a function that would implicitly be called before every call of every member function(except the constructor)and another that would be implicitly called before every return from every member function. They were called call and return functions. They were used to provide synchronization for the monitor class in the original task library...

class monitor : object{
    call() {/*grab lock*/}

    return(){/*release lock*/}

};

In dem Text schreibt Stroustrup weiter, dass er die "Leute"(aka C with Classes/C++-User anno 1980) nicht davon überzeugen konnte, dieses Feature zu nutzen, weshalb es später wieder rausflog.

Ich hatte mit Synchronisation, Multihtreading etc. bisher noch nicht allzu viel zu tun. Ehrlich gesagt hab ich davon Null Ahnung. Also daher die Frage:
Worin bestünde der Vorteil dieses Konstrukts gegenüber nem Mutex, der z.B. in nem Wrapper haust und nur diesen einen Methodenaufruf lockt? So:

class monitor_wrapper{
private:
    monitor m;

public:
    void do_something_locked(){
        mutex_type mutex;          // Evt. als Member?
        mutex.lock()
        m.do_something();
        mutex.unlock();
    }
};

Natürlich hat im C with Classes Design keinerlei Kosten für das Erstellen des Mutex. Dafür jedoch zahlt man mit zwei zusätzlichen Methodenaufrufen (call und return), die jedoch höchst wahrscheinlich geinlined werden können. Man bekommt aber ein Problem, sobald eine Methode keinerlei call(), return()-Funktionalität benötigt und ein zusätzlicher Switch eingebaut werden muss. Sehe ich das richtig?
Außerdem sehe bisher außer dem Locking-Mechanismus keinerlei andere sinnvolle Anwendung darin. Wie seht ihr das?

* aus Thomas J. Bergin, History of Programming Languages II, 1996