Irgendwie klappt das kopieren eines int Wertes in einen int Array nicht.
Bei mir siehts etwa folgendermassen aus:

int* aiMax = new int[10];
int temp = atoi(input); //Funktioniert super, der richtige Wert ist in temp
aiMax[index] = temp; //index ist eine variabel

Da passiert einfach gar nichts der Array hat weiterhin den Wert 0.

Danke für Eure Hilfe.

Da passiert einfach gar nichts der Array hat weiterhin den Wert 0.

An Position index? Btw: Gilt, dass 0 <= index < 10?

Folgender Code-Snippet sollte funktionieren:

#include <iostream>

int main()
{
    int* vec = new int[10];
    index = 9;
    input = 18; // oder ein anderer Wert...
    vec[index] = input;

    std::cout << "vec[" << index << "] = " << vec[index] << std::endl;
    delete[] vec; // Speicher auch wieder freigeben! Nicht vergessen.
}

Gruß Caipi

Ich möchte nur eine Array Element füllen.

@Caipi: Ja, beim Index z.B. 1. Mein Code Snipped sieht ja etwa gleich aus.

Dann poste doch mal deinen, in etwa gleichaussehenden, Code-Snippet :).

Gruß, Caipi

Ich verwende als Index eine Variabel da die ganze Sache später in einer while - Schleife stehen wird.

std::cout << "vec[" << index << "] = " << vec[index] << std::endl;

Dieser Teil Deines Codes verstehe ich nicht, ich denke jedoch, dass dieser nur zur Ausgabe auf der Console ist.

Beim setzen eines Debuggerhaltepunktes hat temp der richtige Wert.

analyzer schrieb:

std::cout << "vec[" << index << "] = " << vec[index] << std::endl;

Dieser Teil Deines Codes verstehe ich nicht, ich denke jedoch, dass dieser nur zur Ausgabe auf der Console ist.

Genau richtig gedacht :).

Gruß, Caipi

//Input
ifstream stream("c:\\file.in");
char input[20];
//Erste Zeile lesen
stream >> input;
//Erste Zeile ist die Anzahl Datensätze
iAnzahlT = atoi(input);
//Array mit der maximale Anzahl an Zahlen
int* aiMax = new int[iAnzahlT];

int iIndex = 0;
while(!stream.eof())
{
//Buffer wieder zurücksetzen
for (int i = 0; i<20; i++)
{
input[i] = -52;
}
stream.getline(input, 20);
int temp = atoi(input);
aiMax[iIndex] = temp;
iIndex++;
}

Wie schon erwähnt bin ich C++ erst am lernen.

3
9
18
27

Mit deinem Code erhalte ich jetzt (nachdem ich eine main() drumgeklatscht habe), einen Segmentation-Fault.

int main()
{
        fstream stream("in.txt");
        char input[20];
        //Erste Zeile lesen
        stream >> input;
        //Erste Zeile ist die Anzahl Datensätze
        int iAnzahlT = atoi(input);
        //Array mit der maximale Anzahl an Zahlen
        int* aiMax = new int[iAnzahlT];

        int iIndex = 0;
        while(!stream.eof())
        {
                //Buffer wieder zurücksetzen
                for (int i = 0; i<20; i++)
                {
                        input[i] = -52;
                }
                stream.getline(input, 20);
                int temp = atoi(input);
                aiMax[iIndex] = temp;
                iIndex++;
        }
        cout << endl;
}

Das liegt daran, dass du in der while Schleife nur auf !stream.eof() testest. eof() liefert aber nur true, wenn das Ende der mit dem Stream assozierten Datei bereits gelesen _wurde_! => Du versuchst in Speicher zu schreiben, der dir nicht gehört! (Siehe dazu auch: hier).
Also änder ich mal den Audruck in der While-Schleife zu.

while(stream.good() && iIndex < iAnzahlT)

.
Desweiteren gebe ich den Speicher mit

delete[] aiMax;

auch wieder frei.

Mit diesen Änderungen sieht der Code so aus:

int main()
{
        fstream stream("in.txt");
        char input[20];
        //Erste Zeile lesen
        stream >> input;
        //Erste Zeile ist die Anzahl Datensätze
        int iAnzahlT = atoi(input);
        //Array mit der maximale Anzahl an Zahlen
        int* aiMax = new int[iAnzahlT];

        int iIndex = 0;
        while(stream.good() && iIndex < iAnzahlT)
        {
                //Buffer wieder zurücksetzen
                for (int i = 0; i<20; i++)
                {
                        input[i] = -52;
                }
                stream.getline(input, 20);
                int temp = atoi(input);
                aiMax[iIndex] = temp;
                iIndex++;
        }
        delete[] aiMax;
}

Mit einer Kontroll-Ausgabe (z.B.)

copy(aiMax, aiMax + iAnzahlT, ostream_iterator<int>(cout, ", ")); // benötigt <iterator> und <algorithm>

Erhalte ich die Ausgabe:

9, 18, 27,

.

So. Jetzt funktioniert der Code-Snippet. Allerdings würde ich ihn Folgendermaßen schreiben:

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
using namespace std;

int main()
{
        fstream stream("in.txt");
        // Fehlerbehandlung einbauen.
        if(!stream)
            return 1;
        int input; // Wenn du sowieso nur Zahlen einließt, wieso deklarierst du
                   // input dann nicht vom Typ int?
        //Erste Zeile lesen
        stream >> input;
        // Es entfallen die lästigen (und unsicheren) Konvertierungen mittels der Funktion atoi().
        int iAnzahlT = input; // Wie soll verfahren werden, wenn input negativ? (In diesem Fall wirft new eine Exception).
        //Array mit der maximale Anzahl an Zahlen
        int* aiMax = new int[iAnzahlT];

        int iIndex = 0;
        while(iIndex < iAnzahlT && stream >> aiMax[iIndex])
        {
                // die For-Schleife entfällt.
                // stream.getline, atoi() und temp ebenfalls.
                iIndex++;
        }
        copy(aiMax, aiMax + iIndex, ostream_iterator<int>(cout, ", ")); // Kontrll-Ausgabe nach cout.
        delete[] aiMax; // Speicher freigeben!
}

Gruß, Caipi

Das zuweisen der Werte im Array funktioniert nun.
Im Textfile stehen nun weitere Angaben:

1 6
0
1 4
1 8
1 7
0
2 2 3
2 1 5
0
0

Ich möchte nun auch die folgenden Zahlen auf einer Zeile sauber auslesen können. Leider gibts da irgendwie ein durcheinander:

6, 1, 1, 1, 0, 2, 2, 5, 0,

Aus diesem Grund habe ich vorher getline verwendet.
Man kann von der Korrektheit der Eingaben ausgehen (keine negativen Werte).

Danke.