C++ Review bzw. Feadback

Gast #4516976
1
class A: public QObject
2
{
3
  Q_OBJECT
4
  
5
  public:
6
  EFILIBRARY_EXPORT A(bool boPower);
7
  EFILIBRARY_EXPORT ~A();
8
  .....
9
  signals:
10
  .....
11
  
12
  
13
  private:
14
  
15
  void *m_pvBclass;     // Bclass ist einen class 
16
  void *m_pvDclassPool; // DclassPool ist einen class
17
  void *m_pvEclassHold; //EclassHold ist einen class
18
  
19
  #define pmaGetBclass()      ((Bclass *) m_pvBclass) 
20
  #define pmaGetDclassPool() ((DclassPool *) m_pvDclassPool)  
21
  #define pmaGetEclassHold(a) (&((EclassHold*) m_pvEclassHold) [static_cast <int>(a)])
22
  
23
  ....
24
};

Mir geht darum vorallem um folgende:
1
...
2
private:
3
  
4
void *m_pvBclass;     // Bclass ist einen class 
5
void *m_pvDclassPool; // DclassPool ist einen class
6
void *m_pvEclassHold; //EclassHold ist einen class
7
  
8
#define pmaGetBclass()      ((Bclass *) m_pvBclass) 
9
#define pmaGetDclassPool() ((DclassPool *) m_pvDclassPool) 
10
#define pmaGetEclassHold(a) (&((EclassHold*) m_pvEclassHold) [static_cast <int>(a)])

Es ist echt scheisse implementiert.
#4517065
Wenns nicht irgendwo anders noch ein ganz abstrusen Trick verwendet 
wird, der die void Pointer braucht.

Wenn nicht, die member Variablen mit ihrem richtigen Typ anlegen, und 
die Setter/Getter als normale Zugriffsfunktionen im Header 
implementieren.

Oliver
Gast #4517128
das hier:
1
  private:
2
  void *m_pvBclass;     // Bclass ist einen class 
3
  void *m_pvDclassPool; // DclassPool ist einen class
4
  void *m_pvEclassHold; //EclassHold ist einen class
kann es so umgeschrieben werden:
1
std::unique_ptr<Bclass> m_Bclass;
2
std::unique_ptr<DclassPool> m_DclassPool;
3
std::unique_ptr<EclassHold> m_EclassHold;

und die FunktionsMacros? Sorry
1
  #define pmaGetBclass()      ((Bclass *) m_pvBclass) 
2
  #define pmaGetDclassPool() ((DclassPool *) m_pvDclassPool)  
3
  #define pmaGetEclassHold(a) (&((EclassHold*) m_pvEclassHold) [static_cast <int>(a)])
#4517344
Ich empfehle dir dich zuerst über Smartpointer zu informieren:
http://de.cppreference.com/w/cpp/memory/unique_ptr
http://de.cppreference.com/w/cpp/memory

Smartpointer sind dazu da die Lebenszeit der Objekte auf die sie Zeigen 
zu verwalten, und diese automatisch freizugeben wen sie nichtmehr 
verwendet werden.

Den Unique Pointer kannst du nur verwenden, wenn du willst, das nur 
dieser eine Pointer darauf existiert, und das Objekt automatisch 
freigegeben wird sobald der Unique Pointer nichtmehr existiert.

Da wir nicht wissen, wozu der Pointer weiterverwendet wird, können wir 
dir auch nicht sagen, ob du ihn hier verwenden kannst. Es ist aber 
relativ wahrscheinlich, dass du normale Pointer verwenden kannst:
1
Bclass* m_Bclass;
2
DclassPool* m_DclassPool;
3
EclassHold* m_EclassHold;

Zu den Funktionsmakros:
1
Bclass* pmaGetBclass(){
2
  return m_pvBclass;
3
}
4
 
5
DclassPool* pmaGetDclassPool(){
6
  return m_pvDclassPool;
7
}
8

9
EclassHold* pmaGetEclassHold( int a ){
10
  return m_pvEclassHold + a; // oder &pvEclassHold[a]
11
}

PS: Das war wohl nichts mit Stack-Overflow, XD
http://stackoverflow.com/questions/36093300/feedback-on-my-spaghetti-code
http://codereview.stackexchange.com/questions/123526/how-can-i-write-the-macro-method-better-please-feadback
Gast #4517499
Hallo,
noch eine kurze Frage, bei diese:
1
EclassHold* pmaGetEclassHold( int a ){
2
  return m_pvEclassHold + a; // oder &pvEclassHold[a]
3
}
bekomme ich diese Fehlermeldung:
1
 error C2036: 'EclassHold*' : unknown size
#4517541
dominik_ schrieb:
> Hallo, noch eine kurze Frage, bei diese:
> bekomme ich diese Fehlermeldung:
> error C2036: 'EclassHold*' : unknown size

Grundlagen! Der Compiler weiss wohl schon, dass EclassHold eine klasse 
ist, aber nicht, was diese beinhaltet oder wie gross sie ist. Ersetze 
die Implementierungen mit Prototypen und packe die Implementierung in 
ein cpp file. Beim Cpp file bindest du alle klasse ein, die du benötigst 
(A und EclassHold)
1
// prototypen
2
Bclass* pmaGetBclass();
3
DclassPool* pmaGetDclassPool();
4
EclassHold* pmaGetEclassHold( int a );
1
// Cpp file
2
#include <path/to/a.hpp>
3
#include <path/to/EclassHold.hpp>
4

5
Bclass* A::pmaGetBclass(){
6
  return m_pvBclass;
7
}
8
 
9
DclassPool* A::pmaGetDclassPool(){
10
  return m_pvDclassPool;
11
}
12

13
EclassHold* A::pmaGetEclassHold( int a ){
14
  return m_pvEclassHold + a; // oder &pvEclassHold[a]
15
}
Gast #4518503
Hallo Daniel,

danke es funktioniert aber es ist mit sehr grosse vorsicht zu geniessen.


Die Ressourcen:
1
Bclass* m_Bclass;
2
DclassPool* m_DclassPool;
3
DclassPool* m_EclassHold;
teilen mehrere Zeigern. Also es kommt dann shared_ptr zu verwendung.

Da ich Visual Studio 2008 benutze, kann ich nicht die Neuerungen in C11 
leider nicht davon gebarucht machen.
Ich habe die neue Boost1_60 Library runtergeladen und in Visual Studio 
eingebunden.

Wie soll denn die Zeiger aussehen?

-> Hier ist meinen Versuch:
1
  
2
  typedef boost::shared_ptr<Bclass>m_Bclass;
3
  typedef boost::shared_ptr<DclassPool>m_DclassPool;
4
  typedef boost::shared_ptr<DclassPool>m_EclassHold;
Ist das richtig so?
#4518558
dominik_ schrieb:
> Die Ressourcen:
...
> teilen mehrere Zeigern. Also es kommt dann shared_ptr zu verwendung.
>
> Da ich Visual Studio 2008 benutze, kann ich nicht die Neuerungen in C11
> leider nicht davon gebarucht machen.

C11 ist der falsche Standard. Du meinst C++11.


> Wie soll denn die Zeiger aussehen?
...
> Ist das richtig so?

Das typedef gehört da nicht hin, es sei denn du möchtest Datentypen 
statt Variablen definieren.
Gast #4518690
@

das stimmt typedef gehört nicht hin:
1
 boost::shared_ptr<Bclass>m_Bclass;
2
 boost::shared_ptr<DclassPool>m_DclassPool;
3
 boost::shared_ptr<DclassPool>m_EclassHold;
#4518758
Ich kenne mich mit boost nicht aus, vermutlich:
1
// Header file
2
boost::shared_ptr<Bclass> m_Bclass;
3
boost::shared_ptr<DclassPool> m_DclassPool;
4
boost::shared_array<DclassPool> m_EclassHold;
5

6
// cpp file
7

8
boost::shared_ptr<Bclass> A::pmaGetBclass(){
9
  return m_pvBclass;
10
}
11
 
12
boost::shared_ptr<DclassPool> A::pmaGetDclassPool(){
13
  return m_pvDclassPool;
14
}
15

16
Bclass& A::pmaGetEclassHold( int a ){
17
  return m_pvEclassHold[a];
18
}
Gast #4518818
Braucht man boost da überhaupt? Geht das nicht ohne?
Letztens habe ich einen Vortrag gehört, deren Tenor war, dass boost 
durch Features von C++-14 komplett ersetzt werden könnte.
Was ist der Vorteil, wenn man da immer noch diese Extra-Bibliothek 
verwendet?
#4518929
PittyJ schrieb:
> Braucht man boost da überhaupt? Geht das nicht ohne?
> Letztens habe ich einen Vortrag gehört, deren Tenor war, dass boost
> durch Features von C++-14 komplett ersetzt werden könnte.
> Was ist der Vorteil, wenn man da immer noch diese Extra-Bibliothek
> verwendet?

boost ist eine Art (inoffizielle) Testbench für Dinge die zukünftig in 
den Standard fließen und wenn er einen aktuelleren Compiler benutzen 
würde, dann hättest Du recht, aber:

> Da ich Visual Studio 2008 benutze, kann ich nicht die Neuerungen in C11
> leider nicht davon gebarucht machen.

Das Ding ist leider Steinzeit.

Und natürlich gibt es laufend neues in boost.

Wobei ich auch die Frage stellen würde, ob ein Umstieg auf eine 
aktuellere Version nicht in Frage kommt, auch wenn dies ggf. mit 
Anpassungen verbunden sein kann.
Gast #4519361
Daniel A. schrieb:
> Bclass& A::pmaGetEclassHold( int a ){
>   return m_pvEclassHold[a];
> }

ich bekomme folgende Fehlermeldung:
1
 error C2040: 'A::pmaGetEclassHold' : 'A&(int)' differs in levels of indirection from 'boost::shared_array<T> (int)'
2
2>        with
3
2>        [
4
2>            T=A
5
2>        ]
#4519372
Ups, hatte beim Kopieren der Datentypen nicht aufgepasst:
1
// Header file
2
boost::shared_ptr<Bclass> m_Bclass;
3
boost::shared_ptr<DclassPool> m_DclassPool;
4
boost::shared_array<EclassHold> m_EclassHold;
5

6
// cpp file
7

8
boost::shared_ptr<Bclass> A::pmaGetBclass(){
9
  return m_pvBclass;
10
}
11
 
12
boost::shared_ptr<DclassPool> A::pmaGetDclassPool(){
13
  return m_pvDclassPool;
14
}
15

16
EclassHold& A::pmaGetEclassHold( int a ){
17
  return m_pvEclassHold[a];
18
}
Gast #4519389
1
// Header file
2
boost::shared_ptr<Bclass> m_Bclass;
3
boost::shared_ptr<DclassPool> m_DclassPool;
4
boost::shared_array<EclassHold> m_EclassHold;
5

6
boost::shared_ptr<Bclass>pmaGetBclass();
7
boost::shared_ptr<DclassPool>pmaGetDclassPool();
8
EclassHold& A::pmaGetEclassHold( int a );
9

10
boost::shared_ptr<Bclass> A::pmaGetBclass(){
11
  return m_pvBclass;
12
}
13
 
14
boost::shared_ptr<DclassPool> A::pmaGetDclassPool(){
15
  return m_pvDclassPool;
16
}
17

18
EclassHold& A::pmaGetEclassHold( int a ){
19
  return m_pvEclassHold[a];
20
}

So passt danke
Gast #4519400
Noch eine Frage bitte:

ich habe sehr viele funktionen, die so in der Form sind:
1
static void fkt_1(Bclass* bClass_p, DclassPool* dClass_p);
2
static void fkt_2(Bclass* bClass_p, DclassPool* dClass_p, EclassHold*eClassHold);
3
....


Das heisst alle Funktionen müssen umgeschrieben werden so ungefähr:
1
static void fkt_1(boost::shared_ptr<Bclass> bClass_p, boost::shared_ptr<DclassPool> dClass_p);
2
...

Ist das richtig?

Sorry bitte
(Firma: Torrox.de) #4519446
dominik_ schrieb:
> Noch eine Frage bitte:
>
> ich habe sehr viele funktionen, die so in der Form sind:
>
1
> static void fkt_1(Bclass* bClass_p, DclassPool* dClass_p);
2
> static void fkt_2(Bclass* bClass_p, DclassPool* dClass_p, 
3
> EclassHold*eClassHold);
4
> ....
5
>
>
>
> Das heisst alle Funktionen müssen umgeschrieben werden so ungefähr:
>
1
> static void fkt_1(boost::shared_ptr<Bclass> bClass_p, 
2
> boost::shared_ptr<DclassPool> dClass_p);
3
> ...
4
>
>

Wahrscheinlich eher nein. Wenn die Funktion eine zusätzliche Referenz 
(nicht im C++ Sprachsinn) auf das übergebene Objekt speichern möchte, 
dann braucht die Funktion den shared pointer. Aber auch dann spricht 
wenig dagegen, die shared pointers per const Referenz zu übergeben:
1
    static void fkt_1(
2
        const boost::shared_ptr<Bclass>& bClass_p, 
3
        const boost::shared_ptr<DclassPool>& dClass_p);
4
...

Wenn die Funktion nur eine Referenz auf ein Objekt braucht, und diese 
Referenz nicht optional ist (die Funktion nicht erwartet, dass der 
Pointer 0 sein kann), dann solltest Du es durch eine C++ Referenz 
ersetzen:
1
    static void fkt_1(
2
        Bclass& bClass_p, 
3
        DclassPool& dClass_p);
4
...

Im Idealfall nimmst Du Deine Umbauarbeiten zum Anlass, noch mal das 
Thema const correctness in Deinem C++ Buch nachzuschlagen und dass ggf. 
auch gerade zu ziehen.

mfg Torsten

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 10 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.