3. Vector in Array umwandeln

Vector in Array umwandeln

  • D

    Ich übergebe die Größe in Bytes

    Fehlerbeschreibung:

    Es wird nichts angezeigt.

    Ich versuche ein Quadrat zu zeichnen.

    Die Punkte sind:
    pos[0]: 0.5 0.5 0.5
    pos[1]: -0.5 0.5 0.5
    pos[2]: 0.5 0.5 -0.5
    pos[3]: -0.5 0.5 -0.5

    Und ich verbinde:

    1, 3, 2
    1, 2, 0

    Wenn ich das von Hand über die arrays mache, dann erhalte ich mein Quadrat, aber wenn ich das per Code über die Vectoren machen lasse, dann ist mein Bild schwarz. (Und wie ich kontrolliere, ob die Koordinaten stimmen, die ich verbinde)

    Das ist das Problem!

    EDIT:

    Und ich weiß, wei man Fragen stellt. Deshalb habe ich gerfragt, wie man einen Vector in ein Array umwandelt.
    ich wusste nämlich, dass es wieder so enden wird, wenn ich mehr Infos als nötig herausgebe. ich habe schon alles in meinem Wissen stehende getan, aber nichts brachte die Lösung. Deshalb habe ich nach der direkten Lösung meienes Problems gefragt, ohne die Geschicht drumrum.

    0
  • ?

    Kannst du einfach mal die Funktion posten, die du aufrufen willst? Der Punkt ist, dass du nicht umwandeln musst, da Vector intern schon ein Array hat, auf das du von aussen auch zugreifen kannst. Wenn du die Funktion postest, können wir dir die Lösung einfach so angeben.

    0
  • D

    ok.

    Hier der normale Aufruf:

    // create a vertex buffer interface called v_buffer
    d3ddev->CreateVertexBuffer(sizeof(vertices),
                               0,
                               CUSTOMFVF,
                               D3DPOOL_MANAGED,
                               &v_buffer,
                               NULL);

    void* pVoid;    // a void pointer

    // lock v_buffer and load the vertices into it
    v_buffer->Lock(0, 0, (void**)&pVoid, 0);
	memcpy(pVoid, vertices, sizeof(vertices));
    v_buffer->Unlock();

    vertices ist das Array. ich würde aber lieber einen Vector verwenden.
    Und ich verwende DirectX 9.
    (Win XP halt...)

    P.S.:

    Mein Momentner Versuch:

    // create a vertex buffer interface called v_buffer
    d3ddev->CreateVertexBuffer(sizeof(CUSTOMVERTEX) * vertices.size(),
                               0,
                               CUSTOMFVF,
                               D3DPOOL_MANAGED,
                               &v_buffer,
                               NULL);

    void* pVoid;    // a void pointer

    // lock v_buffer and load the vertices into it
    v_buffer->Lock(0, 0, (void**)&pVoid, 0);
	memcpy(pVoid, vertices.data(), sizeof(vertices));
    v_buffer->Unlock();

    Er macht einfach nix!

    0
  • A

    Du hast doch sizeof(vertices) oben angepasst, warum also nicht unten?

    // a void pointer

    Prima Kommentar, so nebenbei.

    0
  • Mod

    sizeof(vertices) ist bei einem std::vector so etwas wie 3*Pointergröße. Du musst schon die wirkliche Größe der Daten nehmen, so wie du es in Zeile 2 deines Versuches komischerweise schon getan hast (sogar augenscheinlich richtig).

    edit: Zu langsam.

    0
  • ?

    Bei deinem momentanen Versuch verbirgt sich der Fehler bei sizeof(vertices). sizeof(vertices) gibt dir die Größe eines Objekts der vector Klasse an (d.h. alle Member-Variablen). Das enthaltene Array wird dabei nur als einzelner Zeiger mitgezählt, dessen Länge also nicht mit einberechnet.

    Deswegen: sizeof(typ der in deinem vector gespeichert wird) * vertices.size();

    0
  • D

    Habs gemerkt.

    Lösung:

    // create a vertex buffer interface called v_buffer
    d3ddev->CreateVertexBuffer(sizeof(CUSTOMVERTEX) * vertices.size(),
                               0,
                               CUSTOMFVF,
                               D3DPOOL_MANAGED,
                               &v_buffer,
                               NULL);

    void* pVoid;    // a void pointer

    // lock v_buffer and load the vertices into it
    v_buffer->Lock(0, 0, (void**)&pVoid, 0);
	memcpy(pVoid, vertices.data(), sizeof(CUSTOMVERTEX) * vertices.size());
    v_buffer->Unlock();

    Ich ging davon aus, dass sizeof(CUSTOMVERTEX) * vertices.size() gleichgroß wie sizeof(vertices) ist, dem war aber nicht so!

    Danke!

    0
  • K

    sagenwoller schrieb:

    Bitte verwende nicht &*vec.begin() oder &vec[0] , da das nicht geht, wenn dein Vektor leer ist.

    .data gibt es aber erst ab C++2011.

    (vec.empty() ? 0 : &vec[0])
    kann man noch schreiben in C++98.

    0
  • K

    Die erinnerung schrieb:

    Ich ging davon aus, dass sizeof(CUSTOMVERTEX) * vertices.size() gleichgroß wie sizeof(vertices) ist, dem war aber nicht so!

    Nö, dem ist auch nicht so; denn std::vector speichert den Kram indirekt.

    0
  • D

    krümelkacker schrieb:

    Nö, dem ist auch nicht so; denn std::vector speichert den Kram indirekt.

    Wenn ich das vorher gewusst hätte, aber man lernt eben täglich dazu...

    0
  • Mod

    krümelkacker schrieb:

    Die erinnerung schrieb:

    Ich ging davon aus, dass sizeof(CUSTOMVERTEX) * vertices.size() gleichgroß wie sizeof(vertices) ist, dem war aber nicht so!

    Nö, dem ist auch nicht so; denn std::vector speichert den Kram indirekt.

    Woarus übrigens folgt, dass vector hier wahrscheinlich gar nicht die richtige Datenstruktur ist. Wenn du vorher ein statisches Array hattest, dann wäre std::array (oder std::tr1::array bei älteren Compilern) das C++-Äquivalent. std::vector ist das was in C malloc war (oder auch für die gute alte Technik, wo man in C einfach eine große Zahl als Arraygröße genommen hat und gehofft hat, dass niemand über das Maximum geht.)

    0
  • D

    Ja ne, ich will ja nach und nach Daten rein schreiben...

    Deshalb habe ich Vector genommen, da meines Wissens sich ein std::Array nicht erweitern lässt. Und falls das doch gehen sollte, ich bin mit Vector ganz zufrieden...

    0
  • Mod

    Die erinnerung schrieb:

    Ja ne, ich will ja nach und nach Daten rein schreiben...

    Deshalb habe ich Vector genommen, da meines Wissens sich ein std::Array nicht erweitern lässt. Und falls das doch gehen sollte, ich bin mit Vector ganz zufrieden...

    Dann ist vector schon richtig.

    0
  • A

    Die erinnerung schrieb:

    krümelkacker schrieb:

    Nö, dem ist auch nicht so; denn std::vector speichert den Kram indirekt.

    Wenn ich das vorher gewusst hätte, aber man lernt eben täglich dazu...

    Auch ohne die Implementierung von std::vector zu kennen, ergibt sich das schon daraus, dass sizeof grundsätzlich eine zur Kompilierzeit bekannte Konstante liefert (von VLAs mal abgesehen, aber die gehören auch nicht zu Standard-C++).

    0
  • D

    Athar schrieb:

    Auch ohne die Implementierung von std::vector zu kennen, ergibt sich das schon daraus, dass sizeof grundsätzlich eine zur Kompilierzeit bekannte Konstante liefert

    Das wäre mir neu...

    0
  • V

    http://stackoverflow.com/questions/2615203/is-sizeof-in-c-evaluated-at-compilation-time-or-run-time

    0
  • D

    Ok. Wie ja gesagt ist mir neu. ich dachte, bis her immer, dass das in Runtime-Operator ist, da sich unter umständen die Größe eines Objekts ändern kann...

    0

  • Die erinnerung schrieb:

    [...] da sich unter umständen die Größe eines Objekts ändern kann...

    Unter welchen Umständen könnte das passieren?

    0
  • D

    Ich dachte es wäre möglich. Z.B.: Vector, aber wie ich jetzt weiß, ändert der seine Größe nicht. Wie ja gesagt, ich dachte...

    0
  • Mod

    Die erinnerung schrieb:

    Ich dachte es wäre möglich. Z.B.: Vector, aber wie ich jetzt weiß, ändert der seine Größe nicht. Wie ja gesagt, ich dachte...

    Gehen wir mal zu C:

    int *ptr;
sizeof(ptr); // Meistens 4 oder 8
ptr = malloc(1000000);
sizeof(ptr); // Immer noch 4 oder 8

    Nun klar?

    0
Anmelden zum Antworten