#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string>
using namespace std;

int main()
{
	struct Verwaltung
	{	string Name;
		int Nummer;
	};
	Verwaltung *Personen;

	int n=0;

	cout << "Wie viele Datensaetze wollen Sie eingeben?\t";
	cin >> n;
	Personen=new Verwaltung[n];
	for (int x=0; x<n; x++)
	{	cout << "\nName, Person " << x << ":\t\t";
		cin >> Personen->Name;
		cout << "Nummer, Person " << x << ":\t";
		cin >> Personen->Nummer;
	}
	for (int x=0; x<n; x++)
	{	cout << "\n\nName, Person " << x << ":\t\t";
		cout << Personen->Name;
		cout << "\nNummer, Person " << x << ":\t";
		cout << Personen->Nummer;
	}

	getch();
	return 0;
}

(Ich weiß, ich sollte danach wieder den Speicherplatz löschen, so weit bin ich aber noch nicht, dass ich das gemacht habe)

Das dürfte helfen
Du musst schon angeben, welches Element im Feld zu haben willst. Du schreibst und liest bisher immer nur auf der 1. Stelle

(*Personen[i]).Name;

oder so ähnlich?

getline(cin, (*(Personen+x)).Name);
//getline(cin, (Personen+x)->Name);

EDIT: Pellaeons Lösung geht auch, da man Pointer wie Arrays behandeln kann, und umgekehrt.
EDIT2: Klammern einfügt

Expression: _BLOCK_TYPE_IS_VALID(pHead->nBlockUse)

Personen[i].Name entspricht (Personen + i)->Name oder (*(Personen + i)).Name

Such dir aus was dir am besten gefällt^^

#include <iostream>
#include <cstdlib>
#include <string>

using namespace std;

struct Verwaltung {
  string Name;
  int Nummer;
};

int main() {    
    Verwaltung *Personen=0;

    int n=0;

    cout << "Wie viele Datensaetze wollen Sie eingeben?\t";
    cin >> n;
    while (getchar()!='\n');

    Personen=new Verwaltung[n];
    for (int x=0; x<n; x++)
    {    cout << "\nName, Person " << x << ":\t\t";
        getline(cin, (Personen+x)->Name);
        cout << "Nummer, Person " << x << ":\t";
        cin >> (Personen+x)->Nummer;
        while (getchar()!='\n');
    }

    for (int x=0; x<n; x++)
    {    cout << "\n\nName, Person " << x << ":\t\t";
        cout << (Personen+x)->Name;
        cout << "\nNummer, Person " << x << ":\t";
        cout << (Personen+x)->Nummer;
    }

    delete [] Personen;

    getchar();
    return 0;
}

Oder so (du willst ja bestimmt den ganzen Namen):

getline(cin, *(Personen+x).Name);
//getline(cin, (Personen+x)->Name);

EDIT: Pellaeons Lösung geht auch, da man Pointer wie Arrays behandeln kann, und umgekehrt.

ich seh grad: das geht schief. der "." hat ne höhere Priorität als der * also macht der doch *((Personen+x).Name).

der operator [] bei Zeigern bewirkt, dass automatisch die entsprechende Stelle im Feld adressiert wird UND das der Zeiger dereferenziert wird.

Personen[i].Name entspricht (Personen + i)->Name oder (*(Personen + i)).Name

Such dir aus was dir am besten gefällt^^

Wobei man bei Zeigern aus stilistischen Gründen zu -> raten sollte, v.a. da somit offensichtlicher wird, dass mit einem Zeiger gearbeitet wird.

Pellaeon schrieb:

GPC schrieb:

Oder so (du willst ja bestimmt den ganzen Namen):

getline(cin, *(Personen+x).Name);
//getline(cin, (Personen+x)->Name);

EDIT: Pellaeons Lösung geht auch, da man Pointer wie Arrays behandeln kann, und umgekehrt.

ich seh grad: das geht schief. der "." hat ne höhere Priorität als der * also macht der doch *((Personen+x).Name).

Eh jup, einmal Klammern bitte :xmas2:

habe auch

(Personen + i)->Name

ausprobiert, aber wie erwartet, hat das nix an der fehlermeldung geändert, die nach der ausgabe kommt.

habe den delete befehl in die letzte for-schleife gepackt, aber was stimmt denn an der programmierung nicht, hab schon alles ausprobiert, ohne index, mit index, etc.

for (int x=0; x<n; x++)
	{	cout << "\n\nName, Person " << x << ":\t\t";
		cout << (Personen + x)->Name ;
		cout << "\nNummer, Person " << x << ":\t";
		cout << (Personen + x)->Nummer ;
		delete Verwaltung[x];
	}

delete Verwaltung[x];

Die anweisung als solche ist schon unsinnig (sag blos, das hat dein Compiler geschluckt) - 'Verwaltung' ist der Typ. Du mußt deine Variable löschen und zwar als ganzes:

for(int x=0; x<n; x++)
{
  //Ausgaben
}
delete[] Personen;

Du hast mit new[] ein Feld dynamisch angelegt, dieses kannst du nun auch nur wieder als ganzes mit delete[]freigeben

new <-> delete
new[] <-> delete[]

Also mache das

delete[] Personen;

nachdem zu das Feld nicht mehr benötigst, ergo nach der zweiten for-Schleife

Oder so (du willst ja bestimmt den ganzen Namen):

getline(cin, (*(Personen+x)).Name);
//getline(cin, (Personen+x)->Name);

EDIT: Pellaeons Lösung geht auch, da man Pointer wie Arrays behandeln kann, und umgekehrt.
EDIT2: Klammern einfügt

habe mich jetzt nochmal an das prog gesetzt, und versuche alles zu verstehen. was bewirkt dieses +x genau? Muss ich das unbedingt benutzen?

Dann habe ich noch ne Frage:
In der Berufsschule haben wir ein Aufgabenblatt zur Dyn. Speicherverwaltung bekommen. (Verwaltung von Artikeln) Dort steht:

Als Datenstruktur soll ein 1-dimensionales Array mit Pointern vom Typ T_Artikel gewählt werden, was somit einer halbdynamischen Datenstruktur eintspricht: das Pointer-Array ist statisch, die eigentlichen Artikeldaten werden dynamisch angelegt.

Was ist damit gemeint? - Ist das das gleiche, wie ich bei meinem Prog verwendet habe oder wieder etwas anderes?

"Personen" ist dein Feld. Bei Feldern ist der Name ein Zeiger auf das erste Element im Feld, also die 0.te Stelle sozusagen.
Bei Feldern liegen die Elemente zusammenhängend hintereinander im Speicher, deswegen ja ein Feld
Wenn du jetzt auf das zweite Element zugreifen willst, musst du dich im Feld weiter bewegen. Ein int ist z.B. normalerweise momentan 4 Byte groß. Du müsstes dich also um 4 Adressen weiter bewegen von der Startadresse aus.
C++ ist jedoch clever, jetzt kommt nämlich die Zeigerarithmetik ins Spiel.
Wenn du einen Zeiger + 1 machst, springt er nicht einfach ein Byte weiter, sonder es wird nachgeschaut, von welchem Typ der Zeiger ist und dann wird eine Variable weiter gesprungen. Also am Beispiel hier der erkennt "aha ich zeige auf ein int, int ist 4 Byte groß, also muss ich bei + 1 4 Byte weiter gehen im Feld.

Also sorgt die Zeile (Personen + x) das er die Adresse des x.ten Elements berechnet. Und wenn du nun die Adresse des x.ten Elements hast, kannst du damit arbeiten.

Zu deiner 2. Frage:

Du sollst ein Array von Pointern machen, also

T_Artikel* zeigerFeld[100];

In der Aufgabe steht statisch, also ohne new machen udn einfach nen festen wert abgeben.

Personen[x].Name;

mache funzt es ja genauso.

ich dachte, das funzt nur mit new, da ich sonst keinen speicherplatz habe, jetzt SOLL ich es ohne new machen????
da steig ich nicht durch.
Wie soll denn der entsprechende Speicherplatz reserviert werden, wenn ich kein new verwende???
Wann benutze ich dann new und wann nicht?

"Personen[x].Name" ist äquivalent zu "(Personen + x)->Namen", zumindest in deinem konkreten Fall.
Bei dem statischen Array von Zeigern sieht der Zugriff schon wieder anders aus, weil die Typen anders sind.

#include <iostream>
#include <conio.h>
#include <stdlib.h>
#include <string>
using namespace std;

struct Verwaltung
	{	string Name;
		int Nummer;
	};
	Verwaltung *Personen;

void Arbeiterauflisten(Verwaltung*,int);
void Arbeiterneu(Verwaltung*,int);
void Arbeiteraendern();
void Arbeiterloeschen();

int main()
{
	int n=1;
	char Eingabe;

	do
	{	system("cls");
		cout << "\tPersonalverwaltung";
		cout << "\n\t~~~~~~~~~~~~~~~~~~\n\n";
		cout << "1 --> Vorhandene Arbeiter ansehen";
		cout << "\n2 --> Arbeiter hinzufuegen";
		cout << "\n3 --> Arbeiter aendern";
		cout << "\n4 --> Arbeiter loeschen";
		cout << "\n\n0 --> Programm beenden";
		cout << "\n\nIhre Eingabe:\t";

		cin >> Eingabe;

		switch (Eingabe)
		{
		case '1':
			Arbeiterauflisten(Personen,n);
			break;

		case '2':
			Arbeiterneu(Personen,n);
			break;

		case '3':
			Arbeiteraendern();
			break;

		case '4':
			Arbeiterloeschen();
			break;
		}
	}
	while (Eingabe != '0');

	return 0;
}

void Arbeiterauflisten(Verwaltung *Pers,int v)
{	system("cls");
	cout << "\tIhre Arbeiter:";
	cout << "\n\t~~~~~~~~~~~~~";
	for (int x=0; x<v && Pers[x].Name.length()!=0; x++)
	{	cout << "\n\nName, Person " << x << ":\t\t";
		cout << Pers[x].Name ;
		cout << "\nNummer, Person " << x << ":\t";
		cout << Pers[x].Nummer ;

		getch();
	}
}

void Arbeiterneu(Verwaltung *Pers,int v)
{	char Eing;
	system("cls");
	cout << "\tNeuer Arbeiter:";
	cout << "\n\t~~~~~~~~~~~~~~";
	do
	{	*Pers=new Verwaltung[v];             // Hier kommt der Fehler
		for (int x=0; x<v && Pers[x].Name.length()!=0; x++)
		{	cout << "\nName, Person " << x << ":\t\t";
			cin >> Pers[x].Name;
			cout << "Nummer, Person " << x << ":\t";
			cin >> Pers[x].Nummer;
		}
	cout << "Moechten Sie einen weiteren Arbeiter eingeben? (j/n)\n\n\t";

	}
	while (Eing=='j');

	getch();
}

void Arbeiteraendern()
{	system("cls");
	cout << "\tIhre Arbeiter:";
	cout << "\n\t~~~~~~~~~~~~~";
	getch();
}

void Arbeiterloeschen()
{	system("cls");
	cout << "\tIhre Arbeiter:";
	cout << "\n\t~~~~~~~~~~~~~";
	getch();

}

und bekomme nun den Fehler:

error C2679: Binärer Operator '=': Es konnte kein Operator gefunden werden, der einen rechtsseitigen Operator vom Typ 'Verwaltung *' akzeptiert (oder keine geeignete Konvertierung möglich)