[C++] Array van 10000 getallen met 2 decimalen

[Verwijderd]

Wie weet hoe ik een array van 10000 getallen met 2 decimalen gemaakt krijg want double kan er maar 1000 hebben?
Het is trouwens voor borland c++ (DOS).

[whoami]

double tabel[10000]
of
float tabel[10000]

[Wortelpudding]

code:

float afArray[10000];

Of bedoel je wat anders?

edit:

Oeps, dubbelpost...

[Verwijderd]

Doe maar eens double array[10000] dan krijg je een error van array size too large. Dat is het probleem nou juist.

[Wortelpudding]

Borland C 3 he?

Volgens mij kun je die max array size bij C/C++ options ergens instellen, maar dat weet ik niet zeker...

[whoami]

Gebruik dan een float. Je hebt toch maar 2 decimalen nodig, waarom een double gebruiken? Moeten die getallen zo precies zijn, of kunnen ze zo groot zijn?

Trouwens, ik denk dat als je compileert met het 'huge memory model' ofzo, dat het dan wel moet lukken.

[Verwijderd]

ja die getallen zijn te groot voor een float daarom gebruik ik een double en ik had dat al geprobeert met huge memory model maar dat werkt ook niet.

[Creepy]

Is er geen oplossing mogelijk om zonder een array te werken??

Je zou bijv. niet de eerste zijn die het gemiddelde moet berekenen van max. 10.000 getallen, en hiervoor een array gebruikt terwijl dit helemaal niet nodig is. In dit geval is het genoeg om een totaal bij te houden, en het aantal getallen. Delen door elkaar en klaar.. die 10.000 waarden tel je gewoon meteen bij totaal op, en heb je voor de rest niet meer nodig.

Heb dit helaas erg veel gezien

[Wortelpudding]

Je kunt natuurlijk ook het volgende doen:

code:

double *pdArray;
pdArray = (double*)malloc(10000);

Misschien dattie dit wel vreet...

[Verwijderd]

ja bedankt dat vreet hij wel.

[Verwijderd]

Ik ben even zo vrij geweest om een voorbeeldje in Delphi (console app) in elkaar te knutselen. Zelf geen C++ bij de hand nl. Hopelijk zal er iemand zijn die dit heel snel kan vertalen.

Hier volgt de code van het voorbeeld:

code:

program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils,
  Unit1 in 'Unit1.pas';

var
  X: TDoubleArray;
  I: Integer;
begin
  X:=TDoubleArray.Create;
  X.Add(4.4);
  X.Add(8.9);
  X.Add(44);
  X.Add(1234);
  for I:=0 to X.Count-1 do
    Writeln(FloatToStr(X[I]));
  X.Free;
  Readln;
end.

En hier van Unit1 (waar het eigenlijk om gaat).

code:

unit Unit1;

interface

const
  SIZEOF_DOUBLE=SizeOf(Double);

type
  PDouble=^Double;
  TDoubleArray=class
  private
    FBuffer: Pointer;
    FCount: Integer;
    function GetItem(Index: Integer): Double;
    procedure SetItem(Index: Integer; const Value: Double);
  public
    constructor Create;
    destructor Destroy; override;
    function Add(const Value: Double): Integer;
    procedure Delete(const Index: Integer);
    property Count: Integer read FCount;
    property Items[Index: Integer]: Double read GetItem write SetItem; default;
  end;

implementation

{ TDoubleArray }

constructor TDoubleArray.Create;
begin
  inherited Create;
  FCount := 0;
end;

destructor TDoubleArray.Destroy;
begin
  ReallocMem(FBuffer, 0);
  inherited Destroy;
end;

function TDoubleArray.Add(const Value: Double): Integer;
begin
  ReallocMem(FBuffer, (FCount+1)*SIZEOF_DOUBLE);
  SetItem(FCount, Value);
  inc(FCount);
  Result:=FCount;
end;

procedure TDoubleArray.Delete(const Index: Integer);
var
  I: Integer;
begin
  for I:=Index+1 to FCount do
    SetItem(I-1, GetItem(I));
  ReallocMem(FBuffer, (FCount-1)*SIZEOF_DOUBLE);
  dec(FCount);
end;

function TDoubleArray.GetItem(Index: Integer): Double;
var
  P: PDouble;
begin
  P:=FBuffer;
  inc(P, Index*SIZEOF_DOUBLE);
  Result:=P^;
end;

procedure TDoubleArray.SetItem(Index: Integer; const Value: Double);
var
  P: PDouble;
begin
  P:=FBuffer;
  inc(P, Index*SIZEOF_DOUBLE);
  P^:=Value;
end;

end.

Hopelijk kun je er wat mee.

[Wortelpudding]

Hmmm, zo maak je het wel erg ingewikkeld.

Zo te zien heeft hij alleen maar een fixed-size array nodig...

[Verwijderd]

Op woensdag 22 mei 2002 14:45 schreef MrHuge het volgende:
Hmmm, zo maak je het wel erg ingewikkeld.

Zo te zien heeft hij alleen maar een fixed-size array nodig...

Ach waarom makkelijk doen als het moeilijk kan?
Dit is een eenvoudige class welke als dynamische array (type Double) fungeert.
10000 komt op mij over als een grote array (voor DOS-begrippen). Hierbij moet je toch rekenen op 80000 bytes en dat is ~80KB. Als je 640KB ter beschikking hebt dan is ~80KB niet echt weinig te noemen.

[Wortelpudding]

Ok, maar om dit moeilijke dan weer een beetje makkelijker te maken hebben we dan weer de STL (Standard Template Library) met container-classes voor dit soort dynamische lijsten.

Voordeel hiervan is dat je het wiel geen 2x uit hoeft te vinden.

Bovenstaand een reactie van een luie programmeur

[Creepy]

En in Delphi heb je de container classes hiervoor (TList, TObjectList etc. )

[MSalters]

Op woensdag 22 mei 2002 15:05 schreef MrHuge het volgende:
Ok, maar om dit moeilijke dan weer een beetje makkelijker te maken hebben we dan weer de STL (Standard Template Library) met container-classes voor dit soort dynamische lijsten.

Voordeel hiervan is dat je het wiel geen 2x uit hoeft te vinden.

Bovenstaand een reactie van een luie programmeur

Helemaal gelijk, en de STL is voorbereid om onder DOS met arrays van meer dan 64K te werken ("Huge allocator"); alleen is de compiler waarschijnlijk te bejaard om dat te supporten.

[EXX]

Op woensdag 22 mei 2002 14:06 schreef MrHuge het volgende:
Je kunt natuurlijk ook het volgende doen:

code:

double *pdArray;
pdArray = (double*)malloc(10000);

Misschien dattie dit wel vreet...

Reserveer je zo niet gewoon 10000 bytes met daarop een double pointer? Moet het niet zoiets zijn als:

code:

double *pdArray;
pdArray = (double*)malloc(10000*sizeof(double));

[Wortelpudding]

Op woensdag 22 mei 2002 16:22 schreef EXX het volgende:
Reserveer je zo niet gewoon 10000 bytes met daarop een double pointer? Moet het niet zoiets zijn als:

code:

double *pdArray;
pdArray = (double*)malloc(10000*sizeof(double));

XQses, klopt
Beetje een beginnersfoutje eigenlijk

[RickN]

Mja, maar de topic starter is wel met C++ bezig en dus gebruik je tegenwoordig gewoon:

double array[] = new double[10000]

[porn*]

Of anders met een vector werken? Meteen een dynamische 'array'.

[MSalters]

Op woensdag 22 mei 2002 16:31 schreef RickN het volgende:
Mja, maar de topic starter is wel met C++ bezig en dus gebruik je tegenwoordig gewoon:

double array[] = new double[10000]

Ja, maar de "Borland C++ (DOS)" compiler geeft aan dat de OP in de voltooid verleden tijd programmeert.

[Wortelpudding]

Op woensdag 22 mei 2002 18:24 schreef MSalters het volgende:
Ja, maar de "Borland C++ (DOS)" compiler geeft aan dat de OP in de voltooid verleden tijd programmeert.

Het feit dat iemand met BC3.1 (DOS) programmeert zegt nog niks over het wel/niet gebruiken van C++. Met BC3.1 kun je prima C++ programmeren...

Het gekke is overigens dat je de laatste tijd wel redelijk wat posts ziet van BC3.1 gebruikers. Ik zou wel eens willen weten waarom/waarvoor ze nog zo'n oude compiler gebruiken...

[Creepy]

Ik gok dat het antwoord "school" is, zo te zien aan de vragen..

[Wortelpudding]

Hmmmm, als dat zo is, dan vraag ik me af welke school met een informatica opleiding nu nog leerlingen laat programmeren in een zwaar verouderde programmeeromgeving.
Ik begrijp dat ook met zo'n omgeving de basis van een programmeertaal goed aangeleerd kan worden, maar het lijkt me dat je in je lesstof toch ook het gebruik van een IDE moet aanleren.
De huidige IDE's zijn toch van een heel ander kaliber dan BC3.1

PS: Dit wordt wel een beetje off-topic, maar niet minder interessant

[drm]

Tja ik wil niet vervelend zijn, maar de IDE van Borland roeleert boven allen. Helemaal voor de DOS omgeving. just mho, ofcourse

Maar het gaat niet om de IDE, het gaat om de compiler.

En wat STL betreft, die is -helaas- nog hartstikke brak in die compiler en libraries.

Daarnaast denk ik dat wanneer je in huge memory model compileert het allemaal wel zou moeten werken. (maakt sowieso een hele hoop veel eenvoudiger, huge memory model)

[Gomez12]

Voor lessen aan eerste jaars is het wel een mooie omgeving, alles is lekker basic en simpel.

Plus over Bc3.1 zijn er goedkopere boeken.

[drm]

Gomez12:
Plus over Bc3.1 zijn er goedkopere boeken.

Dat zou ik vreemd vinden, als ze les zouden geven uit een boek specifiek voor bepaalde compiler/omgeving.

Geef dan gewoon les uit Bjarne Stroustrup's boek, en vertel dan wat de compiler wel en niet ondersteunt. Dan krijg je tenminste beetje inzicht in wat de taal C++ kan ipv wat een compiler kan.

[Wortelpudding]

Op donderdag 23 mei 2002 09:24 schreef drm het volgende:
Tja ik wil niet vervelend zijn, maar de IDE van Borland roeleert boven allen. Helemaal voor de DOS omgeving. just mho, ofcourse

Klopt, maar het is in het geval van school toch beter om in een windows-based IDE te werken, omdat dat in 90%-99% van de SW-bedrijven gebruikt wordt. BC3.1 op school is dus niet echt een representatieve situatie voor het 'echte' werk.

Wat de STL betreft, heb je een hele goede STL-implementatie: STLPort http://www.stlport.org.
Deze implementatie wordt met BCB6 meegeleverd (las ik net op de website). Ik vindt dat het brakke van de STL er wel af is.

[whoami]

Da's wel waar, maar op school leer je programmeren. Vooral in het begin is het leren programmeren zonder alle reutemeteut zoals MFC, ATL, ... wel aangewezen vind ik.