Beliebig großes Zahlenarray

[mostwanted90]

Hi@all,

Ich hab mal wieder ein Problem in c++ (wie immer halt)
:suspekt:
Diesmal lautet die Aufgabe

1. Erstelle eine Klasse CINtAray,die eine beliebige Anzahl von int-Zahlen speichern kann. Es sollen mindestens folgende Methoden implementiert werden:

-CIntArray(Groesse, Blockgroesse)
-Copy-Konstruktor (dieser Würde in diesem Fall dann so aussehen: ? CIntArray(CIntArray) oder?
-Zuweisungsoperator
-Add(Zahl)
-GetSize
-SetAt(Index, Zahl)
-Ausgabe()

Es soll im Konstruktor ein Speicher mit der übergebenen Größe angelegt werden. Reicht dieser Wert nicht mehr aus soll ein größerere angelegt werden und die Zahlen umkopiert werden. Die Blockgroesse gibt vor um wieviel der Speicherbereich wachsen soll.


2. Schiebe eine Funktion Eingabe, mit der eine beliebige Anzahl von Zahlen dem Array hinzugefügt werden kann,ein.
3. Überlade den Operator [] so dass folgendes möglich ist:

CIntArray;
Array.Add(1);
Array.Add(2);
Array.Add(3);

array[2] = 5;
int Zahl = Array[2];


Mein erstes Problem liegt darin: Das Array soll im Konstrruktor angelegt werden.

CIntArray::CIntArray(int Groesse,int Blockgroesse)
  {
    
    CIntArray pArray[Groesse];
   ....
  }

Wenn ich mein Quellcode compilieren will kommen folgende fehler.

error C2057: Konstanter Ausdruck erwartet
error C2466: Reservierung eines Feldes der konstanten Groesse 0 nicht moeglich
error C2133: 'pArray' : Unbekannte Groesse

Es ist klar das das Array einen Konstanten Wert braucht aber wieso Fehler2?(Ich gebe in meiner Main funktion der Variablen Groesse den Wert 10 und der Debugger sagt auch das Groesse=10 ist.)
Wie bekomm ich es dann hin das ich Groesse verändern kann aber trotzdem ein Array von der Größe "Groesse" erzeugen kann?

Danke schon einmal im Voraus
mfg Most

 

[RedWing]

Hallo,

Es ist klar das das Array einen Konstanten Wert braucht aber wieso Fehler2?(Ich gebe in meiner Main funktion der Variablen Groesse den Wert 10 und der Debugger sagt auch das Groesse=10 ist.)
Wie bekomm ich es dann hin das ich Groesse verändern kann aber trotzdem ein Array von der Größe "Groesse" erzeugen kann?

Der Compiler kann ja nicht wissen das dein Parameter Groesse zur Laufzeit den Wert 10 übergeben bekommt, deshalb nimmt er die Größe 0 an (da der Compiler ja nur statische Aussagen treffen kann), will heißen das Fehler 2 und 3 nur Folgefehler von Fehler 1 sind.

Wenn du dynamisch Speicher anlegen willst verwende doch den Operator new, damit kannst du dir manuell dynamischen Speicher auf dem Heap besorgen. Und da der von alleine nicht wieder verschwindet bzw deallokiert(da er ja manuell allokiert wurde) wird, musst du dafür Sorge tragen das der Speicher auch im Destruktor mit "delete" wieder freigegeben wird.

Gruß,
RedWing

 

[mostwanted90]

Hi

Ist mir kurz nach dem ich das hier geschrieben habe auch aufgefallen

Danke trotzdem

 

[mostwanted90]

Hi

Ich habe das Programm nun fast fertig

#include "stdafx.h"
#include <conio.h>
#include <iostream.h>
#include <string.h>
#include <search.h>
#include <stdlib.h>
#include <stdio.h>


int cmpFunc(const void* _a, const void* _b)
{
  const float* a = (const float*) _a;
  const float* b = (const float*) _b;
  if(*a > *b) return 1; 
    else
      if(*a == *b) return  0;
      else         return -1;
}
   
 
class CIntArray
{
public:
  CIntArray();
  CIntArray(int Groesse,int Blockgroesse);
  CIntArray(const CIntArray& co);

  
  int Zuweisungsoperator();
  int Clear(int Groesse);
  int Add(int Zahl);
  int Getsize();
  int SetAt(int Index,int Zahl);
  int Ausgabe();
  int AriseArray(int _Blockgroesse);
  int Eingeben();
  int Sortiere();
  int Quicksort();

protected:
  int m_Blockgroesse;
  int* m_pData;
  int m_Groesse;
  int m_Zaehler;  
};


CIntArray::CIntArray()
:m_pData(0),m_Groesse(0),m_Zaehler(0)
{
}


CIntArray::CIntArray(const CIntArray& co)
: m_Groesse(co.m_Groesse), m_Blockgroesse(co.m_Blockgroesse), m_Zaehler(co.m_Zaehler)
{
  m_pData = new int[co.m_Groesse];
  memcpy(m_pData, co.m_pData, m_Groesse*sizeof(int) );
}


CIntArray::CIntArray(int Groesse,int Blockgroesse)
{
  if(m_Zaehler<=0)
  {
    m_Zaehler=0;
  }
  m_Blockgroesse=Blockgroesse;
  m_Groesse=Groesse;
  m_pData = new int[m_Groesse];
}


int CIntArray::AriseArray(int _Blockgroesse)
{
  int* _Temp = new int[m_Groesse + _Blockgroesse];
  memset(_Temp, 0, sizeof(int) * (m_Groesse + _Blockgroesse));
  memcpy(_Temp, m_pData, sizeof(int) * m_Groesse);
  delete[] m_pData;
  m_pData = _Temp;
  m_Groesse += _Blockgroesse;
  return 0;
} 


int CIntArray::Add(int Zahl)
{
  if(++ m_Zaehler >= m_Groesse)
  {
    if(m_Blockgroesse > 0)
    AriseArray(m_Blockgroesse);
    else
    {
      AriseArray(5); 
    }
  }
  m_pData[m_Zaehler-1] = Zahl;
return 0;
}


int CIntArray::Eingeben()
{
  int Groesse=m_Groesse;
  int Zahl;
  cout<<"Bitte Zahl eingeben \n";
  cin>>Zahl;
  return Zahl;
}

int CIntArray::Getsize()
{
 return m_Zaehler;
}

int CIntArray::SetAt(int Index,int Zahl)
{
  if(Index < m_Groesse) {
  m_pData[Index]=Zahl;
  if(Index > m_Zaehler)
  {
   m_Zaehler = Index;
  }
  }
  else 
  { 
    while(Index >= m_Groesse) 
    { 
      AriseArray(m_Blockgroesse > 1?m_Blockgroesse:1);
    }
  m_pData[Index] = Zahl;
  m_Zaehler = Index;
  }
  return 0;
}


int CIntArray::Ausgabe()
{
  for(int x=0; x<=(m_Zaehler-1);x++)
  {
    cout<<m_pData[x+1] <<endl;  
  }
  return 0;
}   


int CIntArray::Sortiere()
{
  for(int x=0;x<=(m_Zaehler-1);x++)
  {
    for(int j=0;j<m_Zaehler;j++)
    {
      if (m_pData[x+1]<m_pData[j])
      {
        int n=m_pData[x+1];
        int z=m_pData[j];
        m_pData[x+1]=z;
        m_pData[j]=n;
      }
    }
  }
  cout<<"Sortiert mit Normaler Sortierung\n";
 return 0;
}


int CIntArray::Quicksort()
{
  qsort((void*) m_pData,m_Zaehler,sizeof(m_pData[0]),cmpFunc);
  cout<<"Ausgabe mit qsort \n"; 
  for(int x=0;x<=(m_Zaehler-1);x++)
  {
    cout<<m_pData[x] <<endl;
  }
return 0;
}


int CIntArray::Clear(int Groesse)
{
     delete[] m_pData;
 return 0;
}


int CIntArray::Zuweisungsoperator()
{
  

  return 0;
}



int main()
{
  int Groesse=10;
  int Blockgroesse=0;
  int Zahl1=0;
  int Index=0;
  int Eingabe=1;
  
  CIntArray();
  CIntArray CIntArray(Groesse,Blockgroesse);
  
  while(Eingabe!=0)
  {
    cout<<"Was möchten sie tun? \n";
    cout<<"1)Zahl eingeben \n";
    cout<<"2)Ausgeben \n";
    cout<<"3)An bestimmter Stelle einen Wert einfügen\n";
    cout<<"0) Beenden \n";
    cin>>Eingabe; 
    switch(Eingabe)
    {  
      case 1:
        {
          Zahl1=CIntArray.Eingeben();
          CIntArray.Add(Zahl1);
          break;
        }
      case 2:
        {
          CIntArray.Quicksort();
          CIntArray.Sortiere();
          CIntArray.Ausgabe();
          break;
        }
      case 3:
        {
          cout<<"An welcher stelle?\n";
          cin>>Index;
          Zahl1=CIntArray.Eingeben();
          CIntArray.SetAt(Index,Zahl1);
        break;
        } 

      default:
        {
          CIntArray.Clear(Groesse);
        }
    } 
  }
  return 0;
}

Ich habe nun aber noch ein Problem.

Der Zuwesisungsoperator soll einem Array ein anderes Array zuweisen.
Wie muss die methode aussehen? Und von wo muss ich sie aufrufen....

Ich danke schon einmal im Vorraus

mfg Most