Rücksendung unterschiedliche Daten je nach Typ der Daten (C++)

Gibt es trotzdem, so etwas zu tun?

(correct pointer datatype) returnPointer(void* ptr, int depth)
{

    if(depth == 8)
        return (uint8*)ptr;
    else if (depth == 16)
        return (uint16*)ptr;
    else
        return (uint32*)ptr;
}

Dank

  • Wie wollen Sie dies zu nutzen? Chancen sind Ihr design folgt nicht, am besten OOP-Praktiken.
  • Das Adobe Photoshop SDK ist das, was ich benutze, und Sie verwenden, void*
  • Könnten Sie ein Beispiel zur Verwendung, darunter ein Anruf zu einem Photoshop-SDK-Funktion?
InformationsquelleAutor Joel | 2009-05-31
  1. 10

    Nicht. Der Rückgabetyp einer C++ - Funktion kann nur variieren, basierend auf expliziten template-Parameter oder die Arten Ihrer Argumente. Es kann nicht variieren, basierend auf der Wert Ihrer Argumente.

    Jedoch, können Sie Sie mit verschiedenen Techniken zu erstellen, die einen Typ haben, der die Vereinigung von mehreren anderen Arten. Leider wird das nicht unbedingt helfen Sie hier, wie eine solche Technik ist ungültig * selbst, und zurück zu dem ursprünglichen Typ wird ein Schmerz sein.

    Jedoch, indem Sie das problem von innen heraus können Sie bekommen, was Sie wollen. Ich denke, Sie würde wollen, verwenden Sie den code, den Sie geschrieben, als so etwas wie zum Beispiel:

    void bitmap_operation(void *data, int depth, int width, int height) {
  some_magical_type p_pixels = returnPointer(data, depth);
  for (int x = 0; x < width; x++)
    for (int y = 0; y < width; y++)
      p_pixels[y*width+x] = some_operation(p_pixels[y*width+x]);
}

    Weil C++ muss wissen, die Art der p_pixels zur compile-Zeit, wird das nicht funktionieren. Aber was wir tun können, ist bitmap_operation selbst eine Vorlage, dann wickeln Sie es mit einem Schalter, basierend auf der Tiefe:

    template<typename PixelType>
void bitmap_operation_impl(void *data, int width, int height) {
  PixelType *p_pixels = (PixelType *)data;
  for (int x = 0; x < width; x++)
    for (int y = 0; y < width; y++)
      p_pixels[y*width+x] = some_operation(p_pixels[y*width+x]);
}

void bitmap_operation(void *data, int depth, int width, int height) {
  if (depth == 8)
    bitmap_operation_impl<uint8_t>(data, width, height);
  else if (depth == 16)
    bitmap_operation_impl<uint16_t>(data, width, height);
  else if (depth == 32)
    bitmap_operation_impl<uint32_t>(data, width, height);
  else assert(!"Impossible depth!");
}

    Nun der compiler generiert automatisch drei Implementierungen für bitmap_operation_impl für Sie.

    • In C# können Sie wieder ein Objekt geben, und werfen Sie es zu Ihrem gewünschten Objekt (vorausgesetzt, Sie kennen den Typ). Oder Sie können verwenden Generika. Können Sie etwas tun, ähnlich wie in c++?
    • Die nächsten C++ ist ein Objekt-Typ ist void *. Es gibt auch boost-Variante geben.
    • Ich glaube, ich würde im boost-Variante zu.
    InformationsquelleAutor bdonlan
  2. 7

    Wenn Sie eine Vorlage verwenden können, argument statt eines normalen parameter, erstellen Sie eine Vorlagen-Funktion, die zurückgibt, den richtigen Typ für jeden depth Wert. Erstens muss es eine bestimmte definition des richtigen Typs nach depth. Definieren Sie eine Vorlage mit Spezialisierungen für die verschiedenen bit-Größen:

    //template declaration
template<int depth>
struct uint_tmpl;

//specializations for certain types
template<> struct uint_tmpl<8>  { typedef uint8_t type; };
template<> struct uint_tmpl<16> { typedef uint16_t type; };
template<> struct uint_tmpl<32> { typedef uint32_t type; };

    Die diese definition kann verwendet werden, um zu erklären, eine vorgefertigte Funktion gibt, die die richtige Art für jedes bit mit dem Wert:

    //generic declaration
template<int depth>
typename uint_tmpl<depth>::type* returnPointer(void* ptr);

//specializations for different depths
template<> uint8_t*  returnPointer<8>(void* ptr)  { return (uint8_t*)ptr;  }
template<> uint16_t* returnPointer<16>(void* ptr) { return (uint16_t*)ptr; }
template<> uint32_t* returnPointer<32>(void* ptr) { return (uint32_t*)ptr; }
    • Das bietet keinen Vorteil gegenüber einer Lösung ohne Vorlage wie returnPointer8(), returnPointer16() und returnPointer32(), da das template-argument muss konstant sein (ich.e bekannt, die durch den Programmierer) sowieso.
    • Dass die template-Argumente werden zur Kompilierzeit bekannt ist eine Allgemeine Eigenschaft von Vorlagen. Noch ist flexibler als anders benannte Funktionen, zum Beispiel könnten Sie so etwas wie Vorlage<int Tiefe> ptradd(void* ptr, int val) { *returnPointer<Tiefe>(ptr) += val; }. Dies funktioniert für alle tiefen. Mit unterschiedlich benannt returnPointer Funktionen müssten Sie auch erklären mehrere verschiedene Varianten von ptradd. Für die Vorlagen-version eine ptradd Funktion ist genug.
    InformationsquelleAutor sth
  3. 1

    Können Sie reservieren Speicher auf dem heap und liefert ein void*, den du gewirkt hast an den Typ, der vergeben war. Seine gefährliche und unsichere Art zu arbeiten und ist ein Alter C-trick.

    Kehren Sie könnten eine union, die enthält alle gültigen Datentypen (und eine Auswahl Indikator).

    Könnten Sie Vorlagen verwenden, die den empfohlenen C++ Weg für diese Art der Sache.

    Können Sie eine Reihe von überladenen Funktionen, die einen parameter (jeden Typs) als Referenz - der compiler entscheiden, welche Funktion aufgerufen wird, basierend auf den Datentyp. Ich bevorzugen Häufig diese Art und Weise, wie ich denke, die die einfachste.

    InformationsquelleAutor gbjbaanb
  4. 0

    Nein, Sie können nicht tun, dass in C++. Die richtige Antwort ist, zurück void *.

    Denken, es von der gegenüberliegenden Seite des Anruf -- und aus der compiler-Sicht bei, dass:

    Wie würde der compiler in der Lage sein, zu überprüfen, ob der Rückgabewert korrekt verwendet wird (wie bei einer Variablen zugewiesen, von der richtigen Art, zum Beispiel), falls es nicht möglich zu wissen, welche der drei return-Typen zurückgegeben werden?

    Zu diesem Zeitpunkt der Begriff " Zuweisung "einer von mehreren Typen", um die Rückkehr Wert bedeutungslos wird. Der return-Typ einer Funktion, die keinen anderen Zweck im Leben, als zu machen es möglich, den compiler zu tun, es ist Arbeit; der compiler muss "eins" geben zu können, führen die Typüberprüfung. Da Sie nicht wissen, welches es ist erst zur Laufzeit, der compiler kann das nicht der Typ der überprüfung für Sie. Sie haben zu sagen, der compiler zu "aufhören zu versuchen," zu entsprechen, der return-Wert auf einen bestimmten Typ Zeiger -- daher zurück ein void *.

    Wenn Ihr Tiefe Argumente, die zur Kompilierzeit bekannt ist, können Sie alternativ auch eine Reihe von Vorlagen wie @sth gezeigt, oder eine Reihe getrennter, voneinander Unabhängiger Funktionen, oder verwenden Sie eine Reihe von zusammenhängenden Funktionen, die Aufforderung eine gemeinsame Umsetzung-Funktion und Besetzung die Rückkehr auf den richtigen Typ. Welche Sie wählen ist oft eine ästhetische Entscheidung.

    Wenn der Wert des depth ist nicht wissen, vor der Ausführung, dann sollten Sie wahrscheinlich zurück void *.

    Nun, ich gehe davon aus, dass Ihre tatsächliche Umsetzung tatsächlich etwas zu produzieren, die Zeiger anderes als das, was dein Beispiel-code zeigt. Dein Beispielcode ist nicht eine tatsächliche Funktion; es ist mehr wie versuchen zu duplizieren, was eine cast tut. Ein cast ist nicht eine Funktion aufrufen; es ist eine compiler-Direktive, um zu versuchen, zu "machen" ist operand in einen bestimmten Typ (genau 'wie', ist eine lange Geschichte für einen anderen post). Es ist nicht die Sprache C++ Betrieb, aber ein compiler in Betrieb. Kann man nicht umschreiben, dass in C++ selbst.

    InformationsquelleAutor Euro Micelli
  5. 0

    können Sie dies tun:

    if(Tiefe==8)
    (uint8*)returnPointer(void* ptr, int Tiefe){ //etc

    InformationsquelleAutor
Schreibe einen Kommentar