Velicina C niza

Konacno sam seo da aktivno ucim C, i to onaj izvorni, normalni, a ne kao sto sam poceo VC++6....koj ce mi to

I sad, evo na sta sam naisao u knjizi:

Maximum Array Size:

Because of the way memory models work, you shouldn't try to create more than 64 KB of data variables for now. An explanation of this limitation is beyond the scope of this book, but there's no need to worry: None of the programs in this book exceed this limitation. To understand more, or to get around this limitation, consult your compiler manuals. Generally, 64 KB is enough data space for programs, particularly the relatively simple programs you will write as you work through this book. A single array can take up the entire 64 KB of data storage if your program uses no other variables. Otherwise, you need to apportion the available data space as needed.

-------------------------------------------------------------------------------------------------------
NOTE: Some operating systems don't have a 64 KB limit. DOS does.
-------------------------------------------------------------------------------------------------------

Kliknite za proširenje...

Ok je sve to. Skontao sam da ne prekoracujem tih 64KB, ali ovo mi deluje poprilicno staro, pa sad da se malo informisem o novijim standardima

Daklem:

1. Kakvo je stanje sa sistemima pocev od win98?

2. Zasto ne smem da prekoracim 64KB?

Pa evo u NOTE-u ti rece zbog DOS ogranicenja, medjutim za win aplikacije to nevazi, prije svega sto je ta knjiga veoma stara i sa danasnjim racunarima tesko da ces doci do nekog limita (koji je mnogo, mnogo veci), sem da pocnes da pravis neki ogroman projekat.
Pozdrav !

limit je 2^32 > 4.000.000.000 na windowsima

Znaci 4 MB grubo receno?
(ako sam lepo sracunao ovako na brzinu)

dobra tema.
imam problem sa domacim iz objektnog programiranja:

u dev-cpp sa g++ kompajleru , kompajliram programce, koji ima sistem klasa, gde poslednja izvedena ima ** ( dupli pointer) na osnovni tip( iz kog je izvedena) kao atribut.Ta klasa ima i metodu za dodavanje pointera na elemente nizu pointera (koji se inicijalizuje kontruktorom na duzinu 0) , i program u windowsu puca posle 20-ak ubacenih elemenata, a u linux-u posle 5-6 prijavljuje segmentation fault

da li neko ima objasnjenje za ovo?
(mozda ako uradim preko povezane liste, a ne preko **, se ovo nece desavati, a ako je tako, da li neko ume da mi objasni zasto je povezana lista "jeftinija" od varijante sa **)
hvala unapred

prilazem pomenuti header fajl:


#ifndef _predmet_h_
#define _predmet_h_
#define pi 3.141592
#include<iostream>
using namespace std;

class Predmet

{
protected:
char oznaka;
public:
virtual double V()=0;
virtual double T()=0;
virtual void citaj(istream& d){cout<<"oznaka?\n";d>>oznaka;}
virtual void pisi(ostream& d){d<<oznaka;}
virtual Predmet* kopija() const=0;

friend istream& operator>> (istream& d, Predmet& p)
{p.citaj(d);return d;}
friend ostream& operator<< (ostream& d, Predmet& p)
{p.pisi(d);return d;}

Predmet(){oznaka=' ';}
Predmet(char oz){oznaka=oz;}
virtual ~Predmet(){}
};


class Telo : public Predmet
{
protected:
double spec;
public:
virtual void pisi(ostream& d)
{
Predmet:isi(d);d<<" , "<<"gustina = "<<spec;
}

Telo()redmet(){spec=1;}
Telo(char oz,double sp=1)redmet(oz){spec=sp;}
virtual ~Telo(){}


};


class Sfera : public Telo

{

double rad;

public:
Sfera():Telo(){rad=0;oznaka='s';}
Sfera(double sp,double r):Telo('s',sp){rad=r;}
~Sfera(){}

virtual double T(){ return V()*spec;}
virtual double V(){ return 4.0f/3.0f*rad*rad*rad*pi; }
Sfera* kopija() const
{return new Sfera(*this);}


void pisi(ostream& d)
{
d<<"<";
Telo:isi(d);
d<<" ,radijus = "<<rad<<" , zapremina "<<V()<<" ,tezina "<<T()<<" >"<<endl;
}
void citaj(istream& d)
{
oznaka='s';
cout<<"radijus?\t";
d>>rad;
cout<<"specificna tezina?"<<endl;
d>>spec;
}

};

class Kupa : public Telo

{

double rad,vis;

public:

Kupa():Telo(){rad=0;oznaka='k';}
Kupa(double sp,double r,double v):Telo('k',sp){rad=r;vis=v;}
~Kupa(){}
virtual double V(){return rad*rad*pi*vis/3.0f;}
virtual double T(){return V()*spec;}
Kupa* kopija() const
{return new Kupa(*this);}
void pisi(ostream& d)
{
d<<"<";
Telo:isi(d);
d<<"(radijus = "<<rad<<",visina = "<<vis<<")";
d<<" , zapremina "<<V()<<" ,tezina "<<T()<<">\n";


}

void citaj(istream& d)
{
oznaka='k';
cout<<"radijus?\t";
d>>rad;
cout<<"\nvisina?\t";
d>>vis;
cout<<"\nspecificna tezina?\t";
d>>spec;
}
};

class Valjak : public Telo

{

double rad,vis;

public:
Valjak():Telo(){rad=0;oznaka='v';}
Valjak(double sp,double r,double v):Telo('v',sp){rad=r;vis=v;}
~Valjak(){}

double V(){return rad*rad*pi*vis;}
double T(){return V()*spec;}
Valjak* kopija() const
{return new Valjak(*this);}
void pisi(ostream& d)
{
d<<"<";
Telo:isi(d);d<<"(radijus = "<<rad<<" , visina = "<<vis<<")";
d<<" , zapremina "<<V()<<" ,tezina "<<T()<<">\n";


}



void citaj(istream& d)
{
oznaka='v';
cout<<"radijus?\t";
d>>rad;
cout<<"\nvisina?\t";
d>>vis;
cout<<"\nspecificna tezina?"<<endl;
d>>spec;
}

};

//////////////////////////////////////////////////////////////////////////////////////////////
// klase za greske //
//////////////////////////////////////////////////////////////////////////////////////////////


class PrekZap{};
class PrekTez{};
class GrIndeks{};
class GrNepoznatIzbor{};

/////////////////////////////////////////////////////////////////////////////////////////////
// klasa Sklop //
/////////////////////////////////////////////////////////////////////////////////////////////





class Sklopublic Predmet
{
protected:
Predmet** pr;
int broj;
public:

Sklop(){pr=new Predmet*;broj=0;}
virtual ~Sklop()
{for(int i=0;i<broj;i++)pr=0;broj=0;}

Sklop* kopija() const {return new Sklop(*this);}


//////////////////////////////////////////////////////////////////////////////////////////////
// dodavanje jednog predmeta //
//////////////////////////////////////////////////////////////////////////////////////////////

virtual void dodaj(istream& d)
{
cout<<"tip? ((s)fera,(k)upa,(v)aljak)";
char izbor;
d>>izbor;
switch(izbor)
{
case 's': case 'S' :
{pr[broj]=new Sfera;pr[broj++]->citaj(d);break;}
case 'k': case 'K' :
{pr[broj]=new Kupa;pr[broj++]->citaj(d);break;}
case 'v': case 'V' :
{pr[broj]=new Valjak;pr[broj++]->citaj(d);break;}
default : {throw GrNepoznatIzbor();break;}
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
// vadjenje jednog elementa //
//////////////////////////////////////////////////////////////////////////////////////////////
void izvadi(int br)
{
Predmet* pomocni;
if(br<1 || br>broj){throw GrIndeks();}
for(int i=br;i<broj;i++)
{
pomocni=pr[i-1];
pr[i-1]=pr;
pr=pomocni;
}
delete pr[--broj];
}
//////////////////////////////////////////////////////////////////////////////////////////////
// ispis u konzoli //
//////////////////////////////////////////////////////////////////////////////////////////////
void pisi(ostream& d)
{for(int i=0;i<broj;i++){d<<"indeks = "<<i+1<<"\n";pr->pisi(d);}}
/////////////////////////////////////////////////////////////////////////////////////////////
// tezina i zapremina //
/////////////////////////////////////////////////////////////////////////////////////////////
double V()
{
double rez=0;
for(int i=0;i<broj;rez+=pr[i++]->V()){}
return rez;
}
double T()
{
double rez=0;
for(int i=0;i<broj;rez+=pr[i++]->T()){}return rez;
}

virtual void citaj(istream& d){dodaj(d);}
};


//////////////////////////////////////////////////////////////////////
// dozvoljena duzina reda //
//////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
// skladiste //
//////////////////////////////////////////////////////////////////////////////////////////////



class Skladiste ublic Sklop
{
double ukzap,uktez;

public:

Skladiste(double ukz,double ukt):Sklop(){ukzap=ukz;uktez=ukt;}

~Skladiste(){ukzap=uktez=0;}
void ubaci(Predmet* p)
{
Sklop:r[broj]=p;
Sklop::broj+=1;
}

void dodaj(istream& d)

{


cout<<"tip? ((s)fera,(k)upa,(v)aljak)";
char izbor;
d>>izbor;
switch(izbor)
{
case 's': case 'S' :
{
pr[broj]=new Sfera;
pr[broj++]->citaj(d);
if(T()>uktez){izvadi(broj);throw PrekTez();}
else if(V()>ukzap){izvadi(broj);throw PrekZap();}
break;
}
case 'k': case 'K' :
{
pr[broj]=new Kupa;
pr[broj++]->citaj(d);
if(T()>uktez){izvadi(broj);throw PrekTez();}
else if(V()>ukzap){izvadi(broj);throw PrekZap();}
break;}
case 'v': case 'V' :
{
pr[broj]=new Valjak;
pr[broj++]->citaj(d);
if(T()>uktez){izvadi(broj);throw PrekTez();}
else if(V()>ukzap){izvadi(broj);throw PrekZap();}

break;
}
default : {throw GrNepoznatIzbor();break;}
}

}

void citaj(istream& d)
{dodaj(d);}






};




#endif

@All : Ne oslanjajte se na tu matoru literaturu. Kada chitate o C/C++u drzhite se standarda, a standard ne propisuje nikakva ogranichenja. Ogranichenje dolazi od platforme na kojoj radi program.
DOS je imao (u "normalnim" adresnim modovima) ogranichenje od 64KB, jer je to velichina segmenta, a da bi se prebacila morao se menjati nachin adresiranja. Uglavnom, da ne duzhim, totalno zastarelo i ne verujem da ima ikakve potrebe da se s'tim podacima bilo ko smara.
32-bitni sistemi imaju teorijsko ogranichenje od 2^32= 4GB.
64-bitni su vec na 2^64, shto ne mogu da se setim koliko je beshe terabajta

@opi :
Ne mogu da chitam toliki kod, ali hint : izbaci duple (**) pointere kad radish sa hijerarhijom klasa, to ti je veliko zlo.
Derived* == Base* ali Derived** != Base**

Kod:

#include <stdio.h>
#include <math.h.>

double ugao, a, b, c, count = 0;

int main()
{
for (ugao = 0; ugao <=3.14; ugao = ugao +0.2)
{
a = 4 - cos (ugao);
b = sin(ugao);
c = sqrt(a*a + b*b);
printf("%d\n", c);
count++;
if (count == 5)
{
printf("\n");
count = 0;
}
}
return 0;
}

Kliknite za proširenje...

Izlaz:

0
1237297389
-440642552
-1151347978
1655659245

1900259091
587142750
1026146396
4254296
-1203414781

-514125418
-2116368896
654007334
-1355564762
-1648697386

-1754549995
Press any key to continue...

Kliknite za proširenje...

Bune me sad ovi minusi. Kako moze da bude negativan???

Radi se o sledecem:
trebaju mi vrednosti promene stranice c zavisno od ugla

slika - www.peruzzi.dzaba.com/forumdata/skica.gif

Zato shto "double" vrednost (varijablu 'c') shtampash kao "int" (%d).

Da si koristio format-specifier za float/double dobio bi normalne vrednosti. Ono shto sada vidish je jednostavno double koji je binarno preslikan u int.

Na pocetku koda, gdje si deklarisao varijable "double" zamijeni sa"float".

Bravo sucur-e, netachan odgovor, nula bambija

Znam sad sam vidio, moras i kod d% staviti f%.
Ja sam C++ programer, tako da ne obracam paznju na izlazni tip varijable, jer u C++ to nema.

U pravu si, donekle.
Toga nema ni u C-u ni u C++, vec u bibliotekama koje se koriste. Mada se biblioteke skoro pa smatraju delom jezika, ipak nije tako, i savrsheno je ispravno koristiti C biblioteke u C++u.
Inache, problem sa formatima za output krije veci problem samih jezika, koji je u ovom sluchaju direktno gadjanje memorije (ili registara) pointerom drugog tipa. Otuda i onaj random output.

Da, jer ako si deklarisao tip kada si i formirao tu varijablu, nema razloga da to ponovo radis u outputu.

Sucur:

Znam sad sam vidio, moras i kod d% staviti f%.
Ja sam C++ programer, tako da ne obracam paznju na izlazni tip varijable, jer u C++ to nema.

Kliknite za proširenje...

A....da....definitivno moram negde da iskopam to sedno poglavlje koje mi fali - input & output ...

ebiga. kako sam uostalom i mogao da znam....

aj sad posto vec nemam to poglavlje, a to ocigledno samo tu i pise, da mi neko ukratko pojasni wtf je %d, %f i tako to? Koliko sam sad ohvatao to je izlazni tip promenljive koja kasnije sledi u argumentu funkcije?

Imash to navedeno u helpu koji stizhe uz svaki kompajler. Recimo, ovde :
http://msdn.microsoft.com/library/d..._fields_.2d_.printf_and_wprintf_functions.asp

izlaz:
%c char
%d int(baza 10) -32... -32...
%u unsigned int (baza 10 ) 0-65...
%o int (baza 8 )
%x int (baza 16 )
%f float( preciznos 7 cifara)
%d double (preciznost 16 cifara)

ulaz:

%c
%d
%u
%o
%x
isto

%f float
%lf long float (t.j.double)

ima jos i %e,%g,%le,%lg , i oni sluze za float i double, ali ne znam tacno po cemu se razlikuju od prethodnih.

Pozdrav

To lave....

Eto sada mozes da predjes na sledece poglavlje :wink:

Ma presao sam....i zavrsio ga. Al mora se opet mao podsetim (nizovi...)

a jel bi mogao neko ukratko sustinski samo da mi objasni kako da odradim grafik funkcije?

verovatno da treba prvo da definisem neke stvari za lociranje pixela i tako to??


inace, ova tema je od sad pa nadalje mesto gde cu da vas smaram raznim pitanjima

Moras da budes malo precizniji, gde ces to da radis, da li je to npr borland-graphics, openGL, ..........

Da, mada najbolje da pocnes, pa gdje zapnes da se javis.

ma bre...necu da radim jer ne znam kako.

pa pitam kako ide proces?
onako po koracima, opste

jedan od nacina je da u opengl-u koristis interpolacione funkcije Bezier, ili nesto slicno, ali , posto bi morao da se upoznas sa dobrim delom opengl-a, samo zbog toga, to mi zvuci malo neprakticno, moj savet ti je :
1) java , tu se relativno lako nacrta nesto
2) ako bas hoces u c, tj c++, onda bgi (borland graphics interface), ali za to ti treba borland c++ kompajler, ili eventualno dev-c++ , koji ja koristim, koji ima dodatak za koji simulira bgi.

http://csjava.occ.cccd.edu/~gilberts/devcpp5/ link za download dev-cpp , a za bgi dodatak, posalji mi privatnu poruku sa mail-om, pa cu da ti posaljem ono sto ti treba da ga pokrenes.

Pozdrav.

Ja mislim da je problem do Monitora.....
Probaj da obrises prasinu sa cipela,to mi deluje kao logicno objasnjenje