#include <stdlib.h>
/* Koordinaten eines Punktes im Raum */
struct punkt {
double x, y, z;
};
/* Daten einer Kugel */
struct kugel {
struct punkt mitte;
double radius;
int material_id;
};
int main( void ) {
struct punkt p;
struct kugel k;
struct kugel *pk;
/* ... */
return 0;
}
Geben Sie C-Anweisungen an, mit denen in der main-Funktion
Platz für eine neue, über den Zeiger pk zugängliche Variable vom Typ
struct kugel angelegt wird. Diese Variable soll mit den Daten einer
Kugel mit Radius 1.5 belegt werden, deren Mittelpunkt im Ursprung (0.0,
0.0, 0.0) liegt und die aus dem Material mit der Identifikation 23
besteht.
Was ist damit gemeint?
Weiß jemand bescheid...
null-checker schrieb:> Was ist damit gemeint?> Weiß jemand bescheid...
Ist schon wieder Hausaufgabenzeit? Frag deinen Lehrer, deine
MitschülerInnen, oder das nächste C-Buch.
Oliver
ja wenn man keinen Ansatz hat, ist es schwierig
struct kugel v;
pk=&v;
v.mitte.x = 0.0;
v.mitte.y = 0.0;
v.mitte.z = 0.0;
v.radius = 1.5;
v.material_id = 23;
Ist des so ungefähr richtig
Wenn ja wo ist der Fehler
null-checker schrieb:> Platz für eine neue, über den Zeiger pk zugängliche Variable vom Typ> struct kugel angelegt wird. Diese Variable soll mit den Daten einer> Kugel mit Radius 1.5 belegt werden, deren Mittelpunkt im Ursprung (0.0,> 0.0, 0.0) liegt und die aus dem Material mit der Identifikation 23> besteht.>> Was ist damit gemeint?
lass mich raten das ganze steht unter der Überschrift Dynamische
Speicherverwaltung. Malloc ist deine Freund in denn fall
1
pk=malloc(sizeof(*pk));
2
if(!pk){
3
printf("He is dead Jim \n");
4
/* Fehler Behandung wenn es kein Speicher gibt,
5
Abbruch mit fehler code wäre gut */
6
}
7
pk->mitte.x=...
Wichtig ist hier auch zu lernen wann du mit denn -> auf Elemente der
structur zugreifst und wann mit den Punkt.
die Brocken C die ich hier gepostet habe sind absichtlich nicht
Kommentiert und einige Lehrer haben mit aussagen wie !pk auch ihre
Probleme. Du solltest sie also nicht nur abschreiben sondern auch
verstehen und ggf. verbessern.
null-checker schrieb:> Wenn ja wo ist der Fehler
Jag es durch den Compiler. Der sagt dir schon mal alle Syntaxfehler.
Compiliert es, dann überleg dir ein Programm, mit dem du testen kannst
ob auch das passiert ist, was passieren soll.
Programmieren lernen besteht nicht darin, dass man einfach irgendwas
hinschreibt und andere fragt ob das richtig ist. Programmieren lernen
ist viel Übung und noch viel mehr Selbstkontrolle ob das was man gemacht
hat auch richtig ist. Da niemand mit diesen Fähigkeiten zur Welt kommt,
muss man das lernen. Wodurch sich der Kreis schliesst: Durch Üben lernt
man Programmierern, durch noch mehr Programmieren bekommt man noch mehr
Übung.
* [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
6
* [math]Formel in LaTeX-Syntax[/math]
7
* [[Titel]] - Link zu Artikel
Sowie ganze lesbare Sätz mit Interpunktion erhöhen die
Akzeptanz.
Wenn man dann noch seine Hausaufgaben nicht einfach hier ablädt, sondern
erst selber sich schlau macht und in Notfällen fragt, wo man nicht
selber weiterkommt, klappt das auch mit einem Forum.
Imon schrieb:>> Was ist damit gemeint?>> lass mich raten das ganze steht unter der Überschrift Dynamische> Speicherverwaltung.
Könnte sein, ich denke aber nicht, dass sie schon so weit sind. Es wird
wohl eher auf erste Begegnungen mit Strukturen hinauslaufen.
Also null-checker: wenn dir malloc() noch überhaupt nichts sagt und auch
im Unterricht noch nicht vorgekommen ist, dann musst du es nicht
unbedingt benutzen. Deine Fragestellung ist in der Hinsicht nicht ganz
eindeutig, man kann sie auf 2 Arten auffassen. Es kommt drauf an, was
genau mit "Variable" im Satzteil "Platz für eine neue, über den Zeiger
pk zugängliche Variable vom Typ struct kugel angelegt wird" gemeint ist.
So wie du das gemacht hast, ist das dem Buchstaben nach richtig, denn du
hast tatsächlich eine Variable angelegt. Allerdings ist das die
unübliche Art, wie so etwas gemacht wird. Das was Imon beschrieben hat,
ist die übliche Art, wenn man mit Pointern arbeitet. Allerdings ist dann
der Begriff 'Variable' dem Buchstaben nach nicht mehr anwendbar. Man
spricht dann eher von einem Objekt oder einer Instanz. Denn ein
Kennzeichen einer Variablen ist es, dass sie einen Namen hat. Eine
mittels malloc erzeugte Instanz hat aber keinen Namen, sondern ist eine
namenlose Speicherfläche, in der eine Instanz eines struct kugel
Objektes hineinpasst, so wie auch bei einer entsprechenden Variablen -
nur eben ohne Namen.
Karl heinz Buchegger schrieb:> Deine Fragestellung ist in der Hinsicht nicht ganz eindeutig,> man kann sie auf 2 Arten auffassen.
Stimmt, danke für denn Hinweis, die lese Art ohne Dynamische
Speicherverwaltung ist mir durch das Netz gegangen.
null-checker schrieb:> Ja okey danke;>> ja malloc befehl bereits behandelt,
OK
Dann hatte Imon recht
> jedoch ist dieser meiner Meinung nach nicht wichtig.
Fehleinschätzung.
Völlige Fehleinschätzung.
> Also passt es schon so.
In dem Falle dann nicht.
Eher eine missverständliche Formulierung in der Fragestellung, die
allerdings nur dann zum Tragen kommt, wenn man mangels weiterem
Umgebungswissen darauf angewiesen ist, im Zweifel auch mal Haare spalten
zu müssen.
Hat man allerdings im Unterricht aufgepasst, dann ist ziemlich klar, wie
die Fragestellung aufzufassen ist. Dynamische Allokierung und Zugriff
über den Pointer.
Macht auch Sinn, denn genauso wird das in der Praxis verwendet.
null-checker schrieb:> Âlso dann so:
Im Prinzip: ja
Im Detail: nein
> struct kugel v = (struct kugel*) malloc(sizeof(struct kugel));
v kann kein struct kugel sein. malloc liefert keine. malloc liefert
einen Pointer. Du castest sogar noch explizit auf einen struct kugel
Pointer (obwohl man das in C eigentlich nicht machen sollte). Alles was
du hast ist ein Pointer. Also brauchst du auch eine Pointervariable um
das was da rechts vom = entsteht speichern zu können.
null-checker schrieb:> struct kugel v = (struct kugel*) malloc(sizeof(struct kugel));
^^ NEIN!
das sollte nicht mal dein Compiler Fressen. v ist ein Fertiges Objekt
der struktur Kugel da kannst du nicht mit malloc Arbeiten. Malloc
arbeitet nur mit Pointen gut zusammen.
vergiss die Variable v die brauchst du nicht. sehe dir die Zeilen an die
ich geschrieben habe und das was dein Lehrer vorgegeben hat.
Sehe dir auch unbedingt nochmal die übungen an die Ihr zu malloc gemacht
habt. Ich glaube hier hast du eine Wissenslücke.
Ausserdem wäre es echt nett von dir wenn du denn Hinweiss von Klaus
beachtest würdest und dein Code als solches Kennzeichnest.
Zeiger pk zugängliche Variable vom Typ struct kugel
angelegt ...
damit ist doch gemeint dass man einen neue Variable anlegen muss.
also muss doch "v" verwendet werden.
null-checker schrieb:> Zeiger pk zugängliche Variable vom Typ struct kugel> angelegt ...>> damit ist doch gemeint dass man einen neue Variable anlegen muss.
Nimm das Wort 'Variable' nicht wörtlich.
Nimm es als Synonym für 'Objekt' oder 'Instanz' (je nachdem welches Wort
ihr im Unterricht benutzt habt)
> also muss doch "v" verwendet werden.
Gemeint war in der Aufgabenstellung mit einiger Sicherheit: Erzeugen sie
ein struct kugel 'Objekt' (eine Speicherfläche groß genug für eine
struct kugel) - ein v ist nicht notwendig. Es reicht völlig aus, wenn pk
auf eine Speicherfläche zeigt, die groß genug für eine struct kugel ist.
Nochmal: Das
kann aufgrund von Datentyp Überlegungen schon mal nicht funktionieren.
Links vom = hast du den Datentyp "struct kugel", rechts vom = hast du
den Datentyp "struct kugel*". Die beiden passen nicht zusammen. Ein
Pointer ist nun mal nicht dasselbe wie das Objekt auf das er zeigt.
Der Zugang zu dem Speicherplatz soll über pk erfolgen
Mit struct kugel v bekommst du eine Schachtel in der du Daten Ablegen
kannst.
Mit struct kugel *pk bekommst du einen Zettel, auf dem steht wo deine
Schachtel ist.
malloc besorgt Platz für die Schachtel und sagt dir wo der ist. Nur
musst du das dann auf einen Zettel schreiben.
damit du denn Unterschied siehst. Wenn du das verstanden hast sehe dir
diesen zweiten Vorschlag an :
1
structkugel*pk;
2
3
pk=malloc(sizeof(*pk));
Der C Standard ( nicht der C++ ) garantiert dir, das alle Pointer
kompatibel zu einem void Pointer sind. Glücklicherweise liefert malloc
einen void Pointer. Der Cast, welchen du machst ist also überflüssig,
vielleicht sogar gefährlich.
Das sizeof(*pk) ist ein Trick aus der Praxis,
wenn du denn Datentyp von pk änderst allociert malloc dennoch die
richtige Größe an Speicher. was bei sizeof(struct kugel); nicht mehr
geht. Das kann bei großen lang laufenden Projekten ein wenig
Kopfschmerzen ersparen.
>> struct kugel v;>
das würde ich an deiner stelle Ersatzlos streichen.
> pk=&v;
Hier reißt du dir ein Speicherleck auf du hast mit malloc Speicher
angefordert welchen du nun mit der Adresse von v überschreibst.
denn Speicher welchen malloc allociert hat ist also für die laufzeit
deines Programms weg.
Ausserdem sollte man Speicher welcher mit malloc geholt wird auch mit
free
wieder freigegeben werden. Free auf ein statische Objekt geht aber nicht
ergo hast du das auch noch nicht gemacht.
> v.mitte.x = 0.0;> v.mitte.y = 0.0;> v.mitte.z = 0.0;>> v.radius = 1.5;> v.material_id = 23;>
Im Prinzip richtig allerdings sagt die Aufgabe ja das du mit pk auf die
Daten zugreifen sollst. Also musst du hier so was machen
1
pk->mitte.x=0.0;/* und so weiter */
2
...
3
free(pk);
4
return0;
Wichtig hierbei ist zu lehren das man auf Datentypen der Structuren auf
zwei unterschiedliche Arten zugreifen kann. Wenn man einen Pointer auf
die Struktur hat nimmt man '->' und wenn man eine Instanz der struktur
hat nimmt man denn Punkt.
Karl heinz Buchegger schrieb:> Nimm das Wort 'Variable' nicht wörtlich.
Ich befürchte auch, daß der Lehrer da die Begriffe etwas unpräzise
verwendet. Der Oberbegriff für alle Daten, die man so im Speicher hat,
ist in C eigentlich "Objekt". Eine Variable ist ein Objekt mit einem
Namen. malloc liefert ein Objekt ohne Namen und damit eigentlich keine
Variable zurück.
null-checker schrieb:> Zeiger pk zugängliche Variable vom Typ struct kugel> angelegt ...>> damit ist doch gemeint dass man einen neue Variable anlegen muss.> also muss doch "v" verwendet werden.
Das ergibt aber in dem Zusammenhang keinen Sinn, da man wie gesagt mit
malloc keine Variablen anlegen kann.
Du kannst nur entweder eine Variable vom Typ struct kugel anlegen und
deinen Zeiger darauf zeigen lassen oder mit malloc() Platz reservieren
und den Zeiger dann darauf zeigen lassen.
Ich gehe davon aus, daß der Leherer letzteres meinte.
Das da:
Thread beobachten
Seitenaufteilung abschalten