it-swarm.com.de

Wie kopiere ich Werte aus einem Array in ein neues?

Ich habe seit einer Woche versucht, dies herauszufinden und stoße immer wieder auf Probleme.

Mein Ziel:

Schreiben Sie eine Funktion, die Speicher für ein ganzzahliges Array zuweist. Die Funktion verwendet als Argument einen Ganzzahlzeiger, die Größe des Arrays und newSize, die zugewiesen werden sollen. Die Funktion gibt einen Zeiger auf den zugewiesenen Puffer zurück. Wenn die Funktion zum ersten Mal aufgerufen wird, ist die Größe Null und ein neues Array wird erstellt. Wenn die Funktion aufgerufen wird, wenn die Arraygröße größer als Null ist, wird ein neues Array erstellt und der Inhalt des alten Arrays wird in das neue Array kopiert. Ihr Kursleiter hat arrayBuilder.cpp als Startcode für diese Programmieraufforderung bereitgestellt. Darüber hinaus ist Lab9_1.exe die ausführbare Datei für diese Anwendung, die Sie testen können.

Der Code:

#include <iostream>
using namespace std;

int * arrayBuilder(int * arr, int size, int newSize);
void showArray(int * arr, int size);

int main()
{
int * theArray = 0;
int i;

cout << "This program demonstrates an array builder function." << endl << endl;

// create the initial array.  The initial size is zero and the requested size is 5.
theArray = arrayBuilder(theArray, 0, 5);

// show the array before values are added
cout << "theArray after first call to builder: " << endl;
showArray(theArray, 5);

// add some values to the array
for(int i = 0; i < 5; i++)
{
    theArray[i] = i + 100;
}

// show the array with added values
cout << endl << "Some values stored in the array: " << endl;
showArray(theArray, 5);

// expand the size of the array.  size is not the original size.  newSize
// must be greater than size.
theArray = arrayBuilder(theArray, 5, 10);

// show the new array with the new size
cout << endl << "The new array: " << endl;
showArray(theArray, 10);

cout << endl;

delete [] theArray; // be sure to do this a1t the end of your program!

system("pause");

return 0;
}

/*
FUNCTION: arrayBuilder
INPUTS Pointer to an array.  Size of the array. If size is zero, arr can be    NULL.
      Size of the new array.
OUTPUTS:  Returns a pointer to allocated memory.  If newSize is greater than size,
      an array of newSize is allocated and the old array is copied into the new
      array. Memory pointed to by the old array is deleted.  All new elements
      are initialized to zero.
*/


int * arrayBuilder(int * arr, int size, int newSize)
{
// TODO: Your code goes here


return NULL; // default return value.  No memory allocated!
}

/*
FUNCTION: showArray
INPUTS: Pointer to an array.  Size of the array. If size is zero, arr can be  NULL.
OUTPUTS:  Prints the contents of the array to the console.
*/


void showArray(int * arr, int size)
{
cout << "arr = ";

for(int i = 0; i < size; i++)
{
    cout << arr[i] << "  ";
}

cout << endl;

}

Meine Probleme: Ich kann nicht herausfinden, wie "arr" und die Werte eines temporären Arrays umgeschaltet werden.

int * arrayBuilder(int * arr, int size, int newSize)
{
// TODO: Your code goes here
    int * temp = new int [newSize];

for (int i = size; i < newSize; i++)
{
        *arr = *temp;
        temp++;
}

return NULL; // default return value.  No memory allocated!
}

ein weiterer Versuch bei der Suche nach Antworten:

int * arrayBuilder(int * arr, int size, int newSize)
{
// TODO: Your code goes here
int * temp = new int [newSize];
memcpy (temp, arr, size *sizeof(int));
// HINT: Design the function before writing it.
delete[]  arr;

for (int i = size; i < newSize; i++)
{
    temp[i] = i;
}

return NULL; // default return value.  No memory allocated!
}

Grundsätzlich ist mein Endziel, die Antwort so aussehen zu lassen:

This program demonstrates an array builder function.

theArray after first call to the builder:
arr = 0 0 0 0 0

some values stored in the array:
arr = 100 101 102 103 104

the new array:
arr = 100 101 102 103 104 0 0 0 0 0

FORTSCHRITT!! Es stürzt nicht mehr ab :-) Hier bin ich gerade:

This program demonstrates an array builder function.

theArray after first call to builder:
arr = -842150451  0  0  0  0

Some values stored in the array:
arr = 100  101  102  103  104

The new array:
arr = -842150451  -842150451  -842150451  -842150451  -842150451  -842150451  -8
42150451  -842150451  -842150451  -842150451

Press any key to continue . . .

Ich werde weiter basteln und alle wissen lassen, wenn ich gegen eine Wand stoße! Nochmals vielen Dank Jungs!

IN ORDNUNG! Endlich muss es richtig angezeigt werden:

This program demonstrates an array builder function.

theArray after first call to the builder:
arr = 0 0 0 0 0

some values stored in the array:
arr = 100 101 102 103 104

the new array:
arr = 100 101 102 103 104 0 0 0 0 0

Das habe ich getan. Ich fühle mich wie ich im zweiten Teil betrogen haben kann, wenn ich 0 Werte für "Temp". Ich war mir darüber im Klaren, dass ich die Daten aus dem vorherigen Array in das neue Array übernehmen und stattdessen einfach neu erstellen würde. (Also funktioniert es nur mit diesem speziellen Satz von Werten [nur Nullen]). Gibt es eine andere Art und Weise, wie ich den zweiten Teil codieren kann, damit er universell mit allen Werten funktioniert, die darauf geworfen werden ???

int * arrayBuilder(int * arr, int size, int newSize)
{
int i = size;
int * temp = new int [newSize];
// What if the size is 0?
if (size <= 0)
{
    while (i < newSize)
    {
        temp[i] = 0;
        i++;
    }
}
// Assuming the size _isn't_ 0
else 
{
// "a new array will be created"  (good)

for (i = 0; i < newSize; i++)
{
    // The contents of the "old" array (arr) will be
    // copied into the "new" array (temp)
    while (i < size)
    {
        temp[i] = arr[i];
        i++;
    }
    while (i >= size && i < newSize)
    {
        temp[i] = 0;
        i++;
    }
    // as a hint, you can address the elements in 
    // both arrays using the [] operator:
    // arr[i]
    // temp[i]

}
}

// "The function returns a pointer to the allocated buffer."
// So, NULL is wrong, what buffer did you allocate?
return temp; // default return value.  No memory allocated!
}
4
Peter

Da hast du dir etwas Mühe gegeben.

Schreiben Sie eine Funktion, die Speicher für ein ganzzahliges Array zuweist.

Der Prototyp für diese Funktion wurde für Sie bereitgestellt:

int * arrayBuilder(int * arr, int size, int newSize);

Die Funktion verwendet als Argument einen Ganzzahlzeiger, die Größe des Arrays und newSize, die zugewiesen werden sollen. Die Funktion gibt einen Zeiger auf den zugewiesenen Puffer zurück.

Dies sagt nichts darüber aus, etwas mit dem "alten" (übergebenen) Array zu tun, daher sollten wir davon ausgehen, dass es in Ruhe gelassen werden muss.

Wenn die Funktion zum ersten Mal aufgerufen wird, ist die Größe Null und ein neues Array wird erstellt.

Der obige Text ist angesichts des Zusammenhangs bedeutungslos. Zögern Sie nicht, Ihrem Lehrer mitzuteilen, dass ich das gesagt habe. Wenn die Größe Null ist, woher wissen Sie, wie viele Elemente zugeordnet werden müssen?

Wenn die Funktion aufgerufen wird, wenn die Arraygröße größer als Null ist, wird ein neues Array erstellt und der Inhalt des alten Arrays wird in das neue Array kopiert.

OK, jetzt ist der Mut, was getan werden muss (du bist so nah dran)

int * arrayBuilder(int * arr, int size, int newSize)
{
    // What if the size is 0?

    // Assuming the size _isn't_ 0
    // "a new array will be created"  (good)
    int * temp = new int [newSize];

    for (int i = size; i < newSize; i++)
    {
        // The contents of the "old" array (arr) will be
        // copied into the "new" array (temp)

        // as a hint, you can address the elements in 
        // both arrays using the [] operator:
        // arr[i]
        // temp[i]

        // something is wrong here...
        *arr = *temp;

        // you definitely _don't_ want to do this
        temp++;
    }

    // "The function returns a pointer to the allocated buffer."
    // So, NULL is wrong, what buffer did you allocate?
    return NULL; // default return value.  No memory allocated!
}
5
Chad

Du hast hier schon die Antwort bekommen:

memcpy (temp, arr, size *sizeof(int));

aber danach machen Sie noch einige andere Fehler. In erster Linie müssen Sie return temp ; nicht return NULL ;

Aber auch die Schleife nach dem delete arr[] ; braucht man nicht

delete arr[] auch nicht, wenn die Größe Null ist.

5
woolstar

Damit Sie erkennen, warum der erste Versuch nicht funktioniert hat:

*arr = *temp;

Dies weist dem alten Array einen Wert aus dem neuen Array zu. Das ist rückwärts.

Aber es zielt nur auf den ersten Wert ab, *arr ändert sich nicht. Sie erhöhen *temp, müssen aber auch *arr erhöhen. (Außerdem ist eine manuelle Zeiger-Manipulation wie diese horrende und memcopy () viel besser. Aber hey, das ist zu Lernzwecken, oder?)

Denken Sie auch an diese Schleife:

for (int i = size; i < newSize; i++)

Das durchläuft einmal für jedes Bit, das newSize größer als Größe ist. Aber Sie machen hier zwei Dinge. 1) Kopieren von Daten und 2) Initialisieren der neuen Daten. Die for-Schleife, die Sie haben, eignet sich zum Durchgehen der neuen Daten, aber nicht zum Kopieren der bereits vorhandenen Daten. Das würde von Null auf Größe gehen, oder?

Und wenn Sie fertig sind, müssen Sie die Adresse des Arrays zurückgeben, das Sie erstellt haben.

return NULL; // default return value.  No memory allocated!

Das ist nur ein Scheincode. Es ist ein Platzhalter des Lehrers. Es ist Teil des Codes, den Sie ändern sollen.

Per Update:

Ich fühle mich wie ich im zweiten Teil betrogen haben kann, wenn ich 0 Werte für "temp" setzen

Nun, was wolltest du sonst noch da reinstecken? Sie kopieren die alten Array-Daten. Dann erweitern Sie das Array. Was geht in das Neuland? Nullwerte als Standard sind vollkommen gültig.

Gibt es eine andere Art und Weise, wie ich den zweiten Teil codieren kann, damit er universell mit allen Werten funktioniert, die darauf geworfen werden ???

Na ja, aber du müsstest tatsächlich etwas zum Werfen haben. Ihre Funktion ArrayBuilder kann zusätzliche Argumente aufnehmen, möglicherweise als variable Funktion , damit sie weiß, welche Werte in die neuen Felder eingefügt werden müssen. Aber Ihre Funktionsdeklaration hat das nicht. Alles was es macht, ist das Array größer zu machen.

Außerdem haben Sie in Ihrer letzten Bearbeitung diese beiden while-Schleifen, die i durchlaufen, innerhalb einer for-Schleife, die auch i durchläuft. Das wird funktionieren, aber nur damit Sie wissen, dass es ein bisschen ... unhöflich ist. Es ist die Art von Dingen, die Sie in Schwierigkeiten bringen, wenn die Dinge komplizierter werden.

Sie könnten dies stattdessen tun:

for (i = 0; i < newSize; i++)
{
  if(i < size)
  {
    temp[i] = arr[i];
  }
  else // if(i >= size && i < newSize) //Wait a sec, this "if" is superfluous. It's conditions are enforced the the first if and the loop condition.
  {
    temp[i] = 0;
  }
}

Sie sollten wahrscheinlich auch die Kommentare löschen, die den Eindruck erwecken, dass jemand anders Ihren Code für Sie geschrieben hat. Weil jemand anderes deine Hausaufgaben für dich gemacht hat. Es ist am besten zu

Schließlich sollten Sie Ihren Code einrücken!

1
Philip

Wenn ich die Zuordnung richtig verstanden habe, sollte die Funktion folgendermaßen aussehen. Zunächst würde ich die Funktionsdeklaration ersetzen

int * arrayBuilder(int * arr, int size, int newSize);

for

int * arrayBuilder( const int *arr, size_t size, size_t newSize );

Hier ist seine Definition

int * arrayBuilder( int * arr, int size, int newSize)
{
   int *tmp = 0;

   if ( newSize >= 0 )
   {
      tmp = new int[newSize] {};

      int copy_size = std::min( size, newSize );

      if ( copy_size > 0 ) std::copy( arr, arr + copy_size, tmp );
   }

   delete []arr;

   return tmp;
}
0

Das ist schrecklich komplexer Code. Bei der Programmierung dreht sich alles um ReduzierungKomplexität.

Vor diesem Hintergrund finden Sie hier eine geeignete C++ - Lösung:

std::vector<int> arr = {1, 2, 3, 4, 5};
std::vector<int> copy = arr;

Das ist es. Ich hoffe, dies zeigt beispielhaft, warum Sie sollte die Standardbibliothek (oder andere geeignete Bibliotheken) verwenden, anstatt das Rad neu zu erfinden. Aufgrund des von Ihnen veröffentlichten Codes gehe ich davon aus, dass Sie C++ aus einem schrecklichen Buch oder Kurs gelernt haben (oder lernen). Entsorge das und hol dir ein richtiges Buch . C++ ist so komplex, dass keine unnötige Komplexität hinzugefügt werden muss.

0
Konrad Rudolph

Versuche dies:

Code:

#include <iostream>

using namespace std;

int a[3] = 
{
    1,
    2,
    3
};

int b[3];

int main ()
{
    cout << endl;
    cout << "Array #1 elements: " << endl;
    for(int i = 0; i < 3; ++i)
    {
        cout << a[i] << " ";
    }

    for(int i = 0; i < 3; ++i)
    {
        b[i] = a[i];
    }
    cout << endl << endl;
    cout << "Copying Array #1 elements to Array #2..." << endl;
    cout << endl;
    cout << "Array #2 elements: " << endl;
    for(int i = 0; i < 3; ++i)
    {
        cout << b[i] << " ";
    }
    cout << endl << endl;
    return 0;
}