Arrays

Ad aCTa

Kurz: Arrays sind Speicherblöcke auf dem Hauptspeicher, die im Gegensatz zu Variablen nebeneinander liegen und so ganz leicht adressiert werden können.
z.B. hat ein Integer im 32-Bit System eine Größe von 4 Bytes. Also machen wir ein Array aus Integer, wo jedes Segment 4 Bytes groß ist. Jedes Byte hat eine Adresse:

int array[6];

Wird im Speicher so aussehen:

+-----------+--------+
| 0x0000004 | inhalt |
| 0x0000008 | inhalt |
| ...       |  ...   |
| 0x000000n | inhalt |
| 0xfffffff | inhalt |
+-----------+--------+

Wobei der Inhalt erst mal undefiniert ist und irgendwas sein kann. Nehmen wir an, du speicherst die Adresse des ersten Elementes in einer Variablen, also kannst du von der aus auf alle anderen zugreifen:

int *ptr = array; // Zeiger nimmt Adresse des Elementes 0 auf
(*ptr) = 5; // Speichere in der ersten Adresse 5
*(ptr + 1) = 3; // Speichere in der zweiten Adresse 3

Wenn du Adresse + n machst, bekommst du die neue Adresse, die derefferenzierst du, um auf die Inhalte zu zu greifen. Für Arrays gibt es stattdessen auch den []-Operator:

int array[8];
array[0] = 5; // ist das selbe wie *array = 5
array[1] = 8; // das selbe wie *(array + 1) = 8

Die Variable array zeigt automatisch auf das erste Element. Innerhalb von den [] gibst du den Offset an, ob 1, 2 ... n. Wenn du zu weit oben oder unten einen Index wählst, etwa array[9], ist das undefiniertes Verhalten und kann abstürzen.
Wenn du dann noch Heap-Arrays willst, wird das noch ein wenig komplexer, Abhilfe schafft da std::vector

---

Wenn du Koordinaten speichern willst, kannst du entweder 2-dimensional vorgehen (Array in einem Array) oder du speicherst ein std::pair in einem Array, wäre bestimmt leichter:

#include <utility>

...

std::pair<int, int> array[10];
array[0] = std::pair<int, int>(4, 6);
std::cout << array[0].first << ' ' << array[0].second << std::endl;

It0101

struct Point
{
   int x, y;
};

// Array anlegen
Point *MeinArray = new Point[10];

// Daten in das Array eintraegn
MeinArray[0].x = 10;
MeinArray[0].y = 11;

// Array wieder löschen
delete [] MeinArray;

freakC++

Wie bereits angedeutet, gibts eine direkte Verwandschaft zwischen Arrays und Zeigern.

Anstatt:

int x1,x2,x3,x4,x5,x6,x7,x8; schreibe ich
int x[7];

Liebe Grüße
freakC++

PS.: Zeige uns Quelltext!!!

camper

Ad aCTa schrieb:

int *ptr = &array; // Zeiger nimmt Adresse des Elementes 0 auf

&array hat den Typ int()[6] nicht int (die Adresse eines Arrays zu bestimmen, führt nicht zu Decay; selbst wenn das anders wäre, müsste das Ergebnis von &array ein int** sein). Also

int* ptr = &array[0]; // oder
int* ptr = array;

Kóyaánasqatsi

It0101 schrieb:

struct Point
{
   int x, y;
};

// Array anlegen
Point *MeinArray = new Point[10];

// Daten in das Array eintraegn
MeinArray[0].x = 10;
MeinArray[0].y = 11;

// Array wieder löschen
delete [] MeinArray;

Du hast aber eine feste Elemente-Zahl angegeben. Das ist undynamisch, das geht besser:

#include <vector>
#pragma pack( 1 ) //Unter VS, wegen Alignment
struct Vector2f
{
	int x, y = 0;
};
#pragma pop( )

std::vector<Vector2f> vec2f;
vec2f.x.push_back(12);
vec2f.y.push_back(3);
//...

freakC++ schrieb:

Wie bereits angedeutet, gibts eine direkte Verwandschaft zwischen Arrays und Zeigern.

Achja, welche direkte Verwandschaft denn genau?

Um es mal verständlicher zu machen, hier ein einfaches Beispiel:

int 2darray[2][10];

	2darray[0][0] = 10; //2darray[0] <- X
	2darray[1][0] = 20; //2darray[1] <- Y

	2darray[0][1] = 15; //2d-array[0] <- X
	//...

KPC

vec2f.x.push_back(12);
vec2f.y.push_back(3);

kompiliert so aber nicht, eher

vec2f.push_back(Vector2f(12,3));

wenn man Vector2f noch einen passenden Konstruktor spendiert.

Sebastian Pizer

Kóyaánasqatsi schrieb:

freakC++ schrieb:

Wie bereits angedeutet, gibts eine direkte Verwandschaft zwischen Arrays und Zeigern.

Achja, welche direkte Verwandschaft denn genau?

Er meinte bestimmt die Syntax für den Zugriff auf ein Element und der/die/das "array-to-pointer decay":

int ding[5]; 
 int *bums = ding; // array to pointer decay 
 ding[2] = 3;
 bums[2] = 3;

Aber da hört es dann auch schon auf mit der Verwandtschaft.

Gruß,
SP

Kóyaánasqatsi

Sebastian Pizer schrieb:

int ding[5]; 
 int *bums = ding; // array to pointer decay 
 ding[2] = 3;
 bums[2] = 3;
Aber da hört es dann auch schon auf mit der Verwandtschaft.

Ich persönlich finde nicht, dass es direkt etwas mit einer Verwandtschaft zu tun hat.

KPC schrieb:

vec2f.x.push_back(12);
vec2f.y.push_back(3);
kompiliert so aber nicht, eher
vec2f.push_back(Vector2f(12,3));
wenn man Vector2f noch einen passenden Konstruktor spendiert.

Hm, ich muss mich entschuldigen, Korrektur:

#include <vector>
#pragma pack( 1 ) //Unter VS, wegen Alignment
struct Vector2f
{
    int x, y = 0;
};
#pragma pop( )

std::vector<Vector2f> vec2f;
Vector2f nVec2f;
nVec2f.x = 10;
nVec2f.y = 20;

vec2f.push_back(nVec2f);
//...

It0101

Du hast aber eine feste Elemente-Zahl angegeben. Das ist undynamisch, das geht besser:

@Koya

er fragte explizit nach Arrays und die bisherigen Erklärungen bezogen sich auch alle auf Arrays. Ich nehm auch fast immer Vector, aber ich denke es ist als Anfänger ganz gut wenn man auch weiß, was Arrays sind.

Kóyaánasqatsi

It0101 schrieb:

Du hast aber eine feste Elemente-Zahl angegeben. Das ist undynamisch, das geht besser:

@Koya

er fragte explizit nach Arrays und die bisherigen Erklärungen bezogen sich auch alle auf Arrays. Ich nehm auch fast immer Vector, aber ich denke es ist als Anfänger ganz gut wenn man auch weiß, was Arrays sind.

std::vector ist ein Array.

whaaatz

kann man dies auch mit datentypen umgehen?

It0101

Natürlich ist vector intern ein array. Aber die (C++)-Welt besteht nunmal nicht nur aus vector...

Kóyaánasqatsi

whaaatz schrieb:

kann man dies auch mit datentypen umgehen?

Was?

whaaatz

Kóyaánasqatsi schrieb:

whaaatz schrieb:

kann man dies auch mit datentypen umgehen?

Was?

kann man mehrere koordinatenwerte bzw. eine Reihe von Koordinaten mit hilfe von datentypen speichern...

Kóyaánasqatsi

whaaatz schrieb:

kann man mehrere koordinatenwerte bzw. eine Reihe von Koordinaten mit hilfe von datentypen speichern...

Klar, wenn du uns nur mal sagen würdest, wie genau du es haben möchtest. Eine Möglichkeit ist die, wie ich sie vorhin schon einmal gepostet habe:

#include <vector>
#pragma pack( 1 ) //Unter VS, wegen Alignment
struct Vector2f
{
    int x, y = 0;
};
#pragma pop( )

std::vector<Vector2f> vec2f;
Vector2f nVec2f;
nVec2f.x = 10;
nVec2f.y = 20;

vec2f.push_back(nVec2f);
//...

In vec2f kannste jetzt so viel pushen wie du möchtest...
BTW: Die Daten können nur in einem Datentypen abgelagert werden, bzw. in deren reservierten Speicher, von daher ergibt deine Frage nicht so viel Sinn.

whaaatz

Kóyaánasqatsi schrieb:

whaaatz schrieb:

kann man mehrere koordinatenwerte bzw. eine Reihe von Koordinaten mit hilfe von datentypen speichern...

Klar, wenn du uns nur mal sagen würdest, wie genau du es haben möchtest. Eine Möglichkeit ist die, wie ich sie vorhin schon einmal gepostet habe:
#include <vector>
#pragma pack( 1 ) //Unter VS, wegen Alignment
struct Vector2f
{
    int x, y = 0;
};
#pragma pop( )

std::vector<Vector2f> vec2f;
Vector2f nVec2f;
nVec2f.x = 10;
nVec2f.y = 20;

vec2f.push_back(nVec2f);
//...
In vec2f kannste jetzt so viel pushen wie du möchtest...
BTW: Die Daten können nur in einem Datentypen abgelagert werden, bzw. in deren reservierten Speicher, von daher ergibt deine Frage nicht so viel Sinn.

struct ist ja auch ein Datentyp, der mehrere Variablen gleichen oder verschiedenen Typs zu einem neuen Datentyp zusammenfasst.

whaaatz

Ich habe mir z.b jetzt vorgenommen, dass ich eine Abfrage von drei Wurfkoordinaten (x und y) und dies speicher in struktur. (Datentyp struct)

Ausgaben dann sollte erneut:
Beispiel

Wurf 0:
x: 9
y: 8

Wurf 1:
x: 4
y: 7

Wurf 2:
x: 3
y: 5

die x und y sind immer wieder veränderbar in der console aber wurf 0,1,2 sind fest gegeben.

Kóyaánasqatsi

Äh? Zeig mal deinen Code.

freakC++

hallo,
noch kurz zu meinem Beitrag. Ich meinte es so, wie SP es erklärt hat. Vielleicht war das Wort "Verwandschaft" schlecht gewählt...

lg, freakC++

whaaatz

Kóyaánasqatsi schrieb:

Äh? Zeig mal deinen Code.

habe noch nicht angefangen, da ich stuct gar nicht gut verstehe

ich will das so programmieren, sodass die ausgage:

wurf0 ( fest)
x: ( veränderbar nach compiliernen) /cin >>
y: "

wurf1:
x:
y:
.
.
.
.

und nachdem ich das letzte mal enter gedrückt habe kommt z.b

"deine Koordinaten sind:"

Wurf 0:
x: 9
y: 8

Wurf 1:
x: 4
y: 7

Wurf 2:
x: 3
y: 5

und dies mit "struct"
ich glaube ich bin zu alt um C++ zu lernen

kann mir da jemand helfen?