🚀 go-pugleaf

Watson <sayegh@fokus.gmd.de> writes:

>Hi,

>dass 

>f() {
>	int x = 10;
>	char s[x];
>}

>nicht geht, ist mir bekannt. Aber ist dies legal:

>f() {
>	int x = 10;
>	char *s = new char[x];
>}

Beides funktioniert. Letzteres sowieso. Ersteres auch. C++-Compiler sind soo
intelligent ;-). Ach so. Letzteres natuerlich nur, wenn Du an entscheidender
Stelle auch wieder 'delete[] s;' aufrufst. :-)

Mach was draus!

Karsten
--
(  Email: Karsten.Baensch@hrz.tu-chemnitz.de                                ( 
 ) WWW:   http://www.tu-chemnitz.de/~kba/baensch.html                        )
(  Phone: (+49-) 0371/531-1252                                              ( 
 ) Mail:  Technical University, Computing Services, 09107 Chemnitz, Germany  )

Watson (sayegh@fokus.gmd.de) wrote:
: Hi,
Hallo...

: f() {
: 	int x = 10;
: 	char s[x];
: }
Wozu soll das gut sein?
Wenn Du x explizit auf 10 setzt, kannst Du ja gleich "char s[10]" schreiben.

: -- 
: *	Greetinx from Watson (sayegh@fokus.gmd.de)
: 	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html
: 	signal(SIGSEGV,SIG_IGN);

-- 
CU                               e-Mail: weini@sbox.tu-graz.ac.at
  STEPHAN                          Fido: Stephan Weinberger@2:316/25.8

Karsten Baensch wrote:
> Beides funktioniert. Letzteres sowieso. Ersteres auch. C++-Compiler sind soo
> intelligent ;-). Ach so. Letzteres natuerlich nur, wenn Du an entscheidender
> Stelle auch wieder 'delete[] s;' aufrufst. :-)


Das stimmt so leider nicht. Die erste Version ist nicht
ANSI-konform (auch wenn der gcc es uebersetzt). Deshalb 
nochmal praezisiert: ist die zweite Variante ANSI-konform?

gcc 2.7.1 -ansi:
warning: ANSI C++ forbids variable-size array
-- 
*	Greetinx from Watson (sayegh@fokus.gmd.de)
	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html
	signal(SIGSEGV,SIG_IGN);

You, Watson <sayegh@fokus.gmd.de> wrote about
Variablen in char[]
in article <310374EE.5322@fokus.gmd.de> of 22 Jan 96:
> Hi,
>
> dass
>
> f() {
> 	int x = 10;
> 	char s[x];
> }
>
> nicht geht, ist mir bekannt. Aber ist dies legal:
>
> f() {
> 	int x = 10;
> 	char *s = new char[x];
> }
>
> ??? Antwort bitte - auch - als PM, Thanx,
      ^^^^^^^
      Auf welche Frage??

Wenn Du meinst, warum das so ist:
        char s[x] wird entweder im Datensegment oder auf dem Stack  
abgelegt, wo der Compiler schon beim Compilieren wissen muss, wie  
gross das Array nachher sein wird, um zB. danach Platz fuer die  
naechste Variable zu reservieren und entsprechenden Code zu  
erzeugen.
        Wenn Du das ganze per new anlegst, kommt der Speicher aus  
dem Heap, der dynamisch vom c/c++-Laufzeitsysytem oder vom  
Betriebssystem verwaltet wird und mit verschidenen Groessen  
zurechtkommen muss. Ausserdem muss die Addresse nicht beim  
Compilieren bakannt sein, weil das Program ja ueber den Pointer  
darauf zugreift.

Read You,
      Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
Mitterfeldstrasse 20, D-83043 Bad Aibling, Germany - fax: ++49-8061-2057
------------------------------------------------------------------------

Watson <sayegh@fokus.gmd.de> schrieb zu
Re: Variablen in char[]
in Artikel <31038E0A.176A@fokus.gmd.de> vom 22.01.96:
> Karsten Baensch wrote:
> > Beides funktioniert. Letzteres sowieso. Ersteres auch. C++-Compiler sind
> > soo intelligent ;-). Ach so. Letzteres natuerlich nur, wenn Du an
> > entscheidender Stelle auch wieder 'delete[] s;' aufrufst. :-)
>
>
> Das stimmt so leider nicht. Die erste Version ist nicht
> ANSI-konform (auch wenn der gcc es uebersetzt). Deshalb
> nochmal praezisiert: ist die zweite Variante ANSI-konform?

Garantiert. Es gibt keinen Grund, das zu verbieten und wenn es  
verboten waere, waere C++ deutlich schlechter.

Claus

------------------------------------------------------------------------
Claus Andre Faerber - claus@faerber.muc.de - http://www.muc.de/~cfaerber
------------------------------------------------------------------------

weini@sbox.tu-graz.ac.at (STEPHAN WEINBERGER) wrote:
 
>: f() {
>: 	int x = 10;
>: 	char s[x];
>: }
>Wozu soll das gut sein?
>Wenn Du x explizit auf 10 setzt, kannst Du ja gleich "char s[10]" schreiben.
  
 
Vielleicht interessiert ihn ja allgemein, ob man Arrays quasi variabel
deklarieren kann, hae ?

Ich wuerde dazu neigen, zu sagen, dass dies os nicht moeglich ist,
waere aber erfreut, etwas anderes zu hoeren. 
Da ich mich mit dem new-operator intern nicht so gut auskenne,
kann es ja sein, dass ich mich irre.

Arnd 

-------------------
e-mail:	Heimann@tu-harburg.d400.de

STEPHAN WEINBERGER wrote:
> Watson (sayegh@fokus.gmd.de) wrote:
> : f() {
> :       int x = 10;
> :       char s[x];
> : }
> Wozu soll das gut sein?
> Wenn Du x explizit auf 10 setzt, kannst Du ja gleich "char s[10]" schreiben.
Stephan,
ich moechte natuerlich diese Gruppe nicht
mit kilometerlangen Listings der Original-
programme belasten, schicke daher die
abstrahierte Fassung (was ich mir auch
von anderen wuenschen wuerde). Wie Du siehst,
macht die Funktion ohnehin NICHTS und gibt
auch nichts zurueck, folglich ist sie bereits
als voellig sinnlos zu erkennen.
Ausserdem denke ich, es gehoert zum guten
Ton, nur auf gestellte Fragen zu antworten.
Die Frage lautete aber gar nicht: kann ich
dafuer nicht auch x[10] schreiben ;-)
Stelle Dir einfach das hier vor:

f(char *s) {
	char x[strlen(s)+1]; /* nicht ANSI konform */
}

ABER:

f(char *s) {
	char *x = new char[strlen(s)+1]; // sehr wohl ANSI konform
	delete [] x;
}

Allen, die mir geantwortet haben einen
herzlichen Dank.
-- 
*	Greetinx from Watson (sayegh@fokus.gmd.de)
	http://www.fokus.gmd.de/ovma/employees/sayegh/entry.html
	signal(SIGSEGV,SIG_IGN);

Watson (sayegh@fokus.gmd.de) wrote:
> Das stimmt so leider nicht. Die erste Version ist nicht
> ANSI-konform (auch wenn der gcc es uebersetzt). Deshalb 
> nochmal praezisiert: ist die zweite Variante ANSI-konform?

Die erste Variante nutzt ein non-ANSI Feature von gcc (Arrays mit variabler
Laenge), die zweite ist voellig legales C++. new() ist (im Gegensatz zu der
Array-Deklaration) eine ganz normale Funktion, die natuerlich auch eine
Variable als Parameter nehmen kann.

Gruss


        Uz

-- 
Ullrich von Bassewitz                              uz@ibb.schwaben.com

Am 22. Jan. 1996 schrieb Watson (sayegh@fokus.gmd.de):

> Das stimmt so leider nicht. Die erste Version ist nicht
> ANSI-konform (auch wenn der gcc es uebersetzt). Deshalb 
> nochmal praezisiert: ist die zweite Variante ANSI-konform?

Ja! (Es wäre auch schlimm, wenn das nicht so wäre, dann könnte man den
ANSI-Standard nämlich wegschmeißen.)


Karl-Heinz Krause