Zeiger auf ein Element aus std::map zurückgeben

Reth

@SeppJ
Super! Vielen Dank! Nein, nicht abgeschrieben nur immer noch elender Anfänger und das Ganze überall versucht zu lernen (aus Web, Büchern, Foren usw.). Hab quasi keine Erfahrung, noch weniger mit dem geconste usw. Hatte vergessen, dass wenn ich einen konstanten Zeiger zurückgeben wöllte, ein const vor den Zeiger-Stern muss, also: const std::vector<FrameC *> const *.
Heißt, so wie ich es jetzt habe, kann zwar der Zeiger verändert werden, nicht jedoch, dass worauf er zeigt - richtig?

Swordfish

@Reth sagte in Zeiger auf ein Element aus std::map zurückgeben:

const std::vector<FrameC *> const *

das ist genau dasselbe wie

@Reth sagte in Zeiger auf ein Element aus std::map zurückgeben:

const std::vector<FrameC *> * // ...

Merk' es dir vielleicht so:

[Typ auf den der Zeiger Zeigt] * [Qualifier des Zeigers] [Name]:

int const * const foo;

und lies von hinten nach vorne: foo ist ein const pointer to const int.

int * const bar;

bar ist ein const pointer to int.

int const * qux;

qux ist ein pointer to const int.

nebenbei:

const const const int const const foo ist dasselbe wie const int foo oder int const foo.

SeppJ

Außer dass doppelte cv-Qualifizierer nicht erlaubt sind?

Reth

@Swordfish
Stimmt, das hatte ich durcheinander gebracht bzw. wieder vergessen (hatte die Schreib- und Leseweisen vor vielen Jahren schon mal angeschaut gehabt, aber in der Zwischenzeit nichts mehr mit C++ gemacht).

Aber nochmal zurück zu meiner anderen Frage:
Heißt, so wie ich es jetzt habe (siehe Eingangspost), kann zwar der Zeiger verändert werden, nicht jedoch, dass worauf er zeigt - richtig?

Swordfish

@SeppJ sagte in Zeiger auf ein Element aus std::map zurückgeben:

Außer dass doppelte cv-Qualifizierer nicht erlaubt sind?

Aja, die Ausnahme war ja long. ([dcl.spec]/2)

@Reth sagte in Zeiger auf ein Element aus std::map zurückgeben:

Heißt, so wie ich es jetzt habe (siehe Eingangspost), kann zwar der Zeiger verändert werden, nicht jedoch, dass worauf er zeigt - richtig?

Ja.

Reth

Besten Dank!

It0101

Desweiteren kannst du dir mal Gedanken machen, ob die ganzen Zeiger wirklich nötig sind. Grundsätzlich sollte man zuerst versuchen nur mit den Objekten selbst, bzw. Referenzen auf die Objekte, zu arbeiten.
Wenn das wirklich nicht geht, dann sollte man über Smart-Pointer ( std::unique_ptr<T>, std::shared_ptr<T> ) nachdenken.

Das nur als Hinweis, wenn du den nächsten Lern-Schritt gehen willst

TGGC

Ich kenne den Zusammenhang nicht, würde aber auch eher dazu tendieren den Iterator statt dem Pointer zurückzugeben. Es geht sonst relativ unnötig Information verloren, z.B. Die Map sollte z.b. Debugfunktionen haben um zu testen das der Iterator zur Map gehört. Würde auch eher zu keinen Pointern im Vector raten vermute aber das hat mit Vererbung zu tun.

SeppJ

@TGGC sagte in Zeiger auf ein Element aus std::map zurückgeben:

Würde auch eher zu keinen Pointern im Vector raten vermute aber das hat mit Vererbung zu tun.

Wahrscheinlich ja. Wobei da direkt auffällt, dass das so aussieht, als wären hier die Besitzverhältnisse nicht geklärt. Weder wird hier ein Pointertyp verwendet, der die Besitzverhältnisse ausdrückt; noch ist ein roher Vector ein Typ, der Besitz auf indirekt verwiesene Ressourcen anmeldet. Daher wäre es schon interessant zu erfahren, was da genau dahinter steckt, denn höchstwahrscheinlich liegt hier ein Fehler vor. Der Threadersteller macht sich ja grundsätzlich Gedanken um Gültigkeit von Verweisen, daher wäre jetzt eine gute Gelegenheit, ihm die saubere Modellierung von Besitzverhältnissen beizubringen.

SeppJ

@Swordfish sagte in Zeiger auf ein Element aus std::map zurückgeben:

@SeppJ sagte in Zeiger auf ein Element aus std::map zurückgeben:

Außer dass doppelte cv-Qualifizierer nicht erlaubt sind?

Aja, die Ausnahme war ja long. ([dcl.spec]/2)

Ähh, long mag zwar doppelt vorkommen dürfen, aber auch nur, weil es dann eine andere Bedeutung hat.

wob

error: 'long long long' is too long for GCC

https://www.youtube.com/watch?v=R2ml28eKMeg

hustbaer

@wob sagte in Zeiger auf ein Element aus std::map zurückgeben:

error: 'long long long' is too long for GCC

https://www.youtube.com/watch?v=R2ml28eKMeg

Ja, long long long ist falsch, korrekt wäre long long li long.
https://www.youtube.com/watch?v=uc2UEfWjvo8

SeppJ

long int long i;  // 100% korrektes C++

Ahhh!

PS:

 const long typedef int volatile long i;  // Auch 100% korrekt

Vielleicht ist C++ doch nicht so schön wie gedacht.

hustbaer

int volatile long static unsigned const long i = 42;

EinNutzer0

Ich raffs nicht. Wieso nicht einfach so was:

#include <iostream>
#include <vector>
#include <map>

struct A
{
    uint32_t id;
    uint32_t irgendwas_anderes;
};

std::map<uint32_t, std::vector<A>> my_map;

const std::vector<A> get_id(const uint32_t id)
{
    std::map<uint32_t, std::vector<A>>::iterator iter = my_map.find(id);
    if (iter != my_map.end())
    {
        return iter->second;
    }
    return {};
}

int main()
{
    my_map[1] = std::vector<A>{{8, 1111}};
    my_map[2] = std::vector<A>{{4, 111}, {8, 1111}};
    my_map[3] = std::vector<A>{{2, 11}, {4, 111}, {8, 1111}};
    my_map[4] = std::vector<A>{{1, 1}, {2, 11}, {4, 111}, {8, 1111}};

    std::cout << get_id(0).size() << std::endl;
    std::cout << get_id(4)[3].irgendwas_anderes << std::endl;
    std::cout << get_id(5).size() << std::endl;
}

Swordfish

Dieser Beitrag wurde gelöscht!

@EinNutzer0 sagte in Zeiger auf ein Element aus std::map zurückgeben:

const std::vector<A> get_id(const uint32_t id)

Jedesmal eine Vectorkopie ausliefern?

EinNutzer0

@manni66 sagte in Zeiger auf ein Element aus std::map zurückgeben:

@EinNutzer0 sagte in Zeiger auf ein Element aus std::map zurückgeben:

const std::vector<A> get_id(const uint32_t id)

Jedesmal eine Vectorkopie ausliefern?

Stimmt, danke... also doch einen Zeiger zurückgeben.

Reth

Au backe! So viel kann ich wohl kaum auf einmal beantworten. Ich probier mich mal grob von meinem letzten Post aus vorzuhangeln.

Also erst einmal als Grundsituation: Ich entwickle gerade auf dem Amiga mit dort leider noch einer alten Toolchain (GCC 4.2.4), da ich das Projekt vor Jahren begonnen hatte und es dazwischen eingeschlafen war (meine Hobbies alternieren ). Das schränkt die C++ Möglichkeiten schon mal ein.

Einen Vector von Zeigern habe ich gemacht, weil ich nicht will, dass ewig hin und her kopiert wird, da dies Laufzeit kostet (und andere unschöne Nebenwirkungen hat, wenn man nicht aufpasst).
Zurückgeben möchte ich einen Zeiger auf einen Vektor, da die dazugehörenden Frames mehrfach verwendet werden sollen, in verschiedenen Animationen (die darzustellenden Frames sind immer die gleichen, jede Animation kann aber z.B. zeitlich anders ablaufen usw.) - auch um etwas effizienter zu sein und nicht jedesmal die gleichen Frames neu im Speicher anzulegen. Das Ganze ist natürlich nur ein Auszug aus einem viel größeren Kontext (Spiel) - eine ältere Version kann man hier begutachten (die Website ist bewusst so gestaltet, damit sie auf Amigas mit älteren Browsern angezeigt werden kann).

Derzeit schaue ich gerade, ob ich mir eine aktuellere Toolchain installiere (gcc und dann nach und nach versuche, umzustellen (auf auto, range based fors, usw. usf.). Allerdings kenne ich die neueren Konzepte noch weniger als die alten (bin nach wie vor blutiger C++ Anfänger und meine C-Jahre liegen auch schon sehr lange zurück!).

Hoffe, das erklärt das Ganze ein bisschen...

SeppJ

Wenn du mehr Indirektion aus Performancegründen einsetzt, dann erreichst du genau das Gegenteil von dem, was du möchtest. Jetzt liegt dein Zeugs kreuz und quer im Speicher, und bei jedem Zugriff muss erst einmal Schnitzeljagd gespielt werden, um an die eigentlichen Nutzdaten zu kommen. Kopier einfach deinen Vector nicht! Ist ganz einfach. Du könntest beispielsweise stets nur indirekt darauf verweisen

Ansonsten: Das wichtige Grundkonzept, aus das alle hier hinaus wollen, und das dir wahrscheinlich nicht so ganz geläufig ist, ist "RAII". Aber besser eigentlich, wenn man selbst das gar nicht erst braucht, die sogenannte "Rule of Zero". (Alles gut googelbare Begriffe)

Allgemein ist es eigentlich ein eher schlechtes Zeichen, wenn du in C++ vielen Zeigern begegnest. Unter der Haube ist natürlich vieles ein verkappter Zeiger, aber wenn du selber viele * in deinem Programm benutzt, dann ist oft etwas falsch. C++ ist halt doch nicht C mit class und cout. Viel krasser noch mit new oder gar malloc. Die mögen zwar auch unter der Haube vorkommen (macht beispielsweise der Vector intern), aber wenn das jemals explizit in einem Programm steht (Wie sind beispielsweise deine Zeiger initialisiert worden?) dann gilt das quasi als Fehler in C++. Siehe oben zu RAII und Rule of 0.

Ich kann dir aber natürlich nicht in 5 Minuten C++ beibringen