sayso

Hallo, wenn ich einen Wert der Structur hostent ausgeben will funktioniert es einfach nicht und ich finde meinen Fehler imo nicht. Vllt . könnt ihr weiterhelfen: int myfunc(int int_socketc, struct sockaddr_in *str_socketc) { unsigned long int lon_hostip; struct hostent *str_host; lon_hostip = inet_Addr(inet_ntoa(str_socketc->sin_addr)); str_host = gethostbyaddr ((char *)&lonhostip, sizeof(lon_hostip), AF_INET); if ( str_host = NULL) { fprintf (stderr, "blablabla"); } fprintf (stderr, "%s", str_host->h_name); } wenn das programm auf die fprintzeile läuft in der ich den hostnamen ausgeben will (die letzte zeile), dann bringt er mir immer einen speicherzugriffsfehler ... :beagolisc :beagolisc Der Zeiger str_socketc zeigt auf die richtige Struktur, da hier auch die IP drinsteht von der an die Socketverbindung connectiert wurde... Nur wenn ich den h_name ausgeben will bringt er mir einen Speicherzugriffsfehler... kann mir mal jemand helfen?

Ok Das war der Sprung der mir bisher immer gefehlt hat, ich dachte immer das er den Speicher erst immer dann allokiert wenn er an den Punkt des Codes kommt indem ein "neuer Text" benötigt wird. Aber wenn er ales von Anfang an macht, dann ist das mit den Zeiger auch zu 100% logisch. Ok danke. Das oben ist ein Beispielcode und ich dachte die Funktion schreibt immer auf den Speicherbereich auf den der Zeiger zeigt (wie bei den Literalen). Das war für mich so nicht nachvollziehbar Aber wenn das die Winows-Socket function handelt ist ja alles gut Also nochma vielen Dank ein dicken :byby: :byby: an alle *g*

Hallo, also erstmal danke für eure Geduld mit mir :hells: Ich habe wirklich schon mit Zeigern gearbeitet mich jedoch nur mit integer und long zeigern und da habe ich mir ehrlich gesagt keine Mühe gemacht über die Speicherallokierung gedanken gemacht. Zum Thema Literal: Wenn ich den Code übersetze und einen strings auf das Programm mache und dann den Text sehe ist das ein Literal richtig? Zum Thema "char *variable." Mit dem Papier und Bleistift Beispiel ist dies jetzt auch klar: char *test = "Testmessage \n"; printf("%s",test); test = "muhh \n"; printf("%s",test); Bei diesem Beispiel schreibe ich radiere ich die alte Adresse ja weg und schreibe eine neue auf den Zettel. D.h. aber die beiden Häuser "Testmessage " und "muhh" müssen zur Laufzeit schon bestehen - Richtig? D.h. das Programm allokiert den Speicher für die beiden Nachrichten beim starten bzw. beim wechseln in die Funktion automatisch? Das mit malloc habe ich jetzt verstanden Das mit den Beispielprogramm und den Adressen der zeigern *autsch* ist auch logisch Und jetzt meine letzte Frage: Der Code ist nicht vollständig aber die IP des Hostes bekomme ich automatisch von anderen Funktionen d.h. er kann sich ändern. Das Programm läuft in einer Schleife. Meine Frage: Kann es hier jetzt zu undefinierten Verhalten kommen? Ich meine nicht denn ich biege den Zeiger ja nur auf die "neue IP" um. Aber wohin schreibt das Programm dann den Output der Funktion "inet_ntoa(cli.sin_addr))" - ja irgendwo in den Speicher... aber es räumt ihn ja nicht weg, solange das Programm nicht verlassen wird oder - denn main ist ja "die Hauptfunktion"? d.h. es ist eigentl. ein Speicherfresser? ausgabe(char *message) { printf ("hostname: %s", message); } void main() { char *host= ""; // hier ist normalerweise ein code mit schleife host= inet_ntoa(cli.sin_addr)); // hier wird die IP lesbar gemacht ausgabe(host); // hier ist normalerweise ein code mit schleife } Danke

Hi, ok wenn man es so sieht, ist es logisch. wenn der zeiger durch ändern der Literale automatisch auch einen anderen Speicherbereich nimmt (= auf etwas anderes zeigt), dann erklärt sich auch warum man es ändern kann.. Für mich war der Begriff "Konstante", ein wirklich konstanter Wert der nicht verändert werden kann. Wird der alte Speicherbereich eigentl. automatisch wieder freigegeben (ohne beendigung des programms oder ohne verlassen von funktionen in der der zeiger verwendet wird) wenn der Zeiger "umgebogen" wird, oder bleibt der speicherbereich allokiert bis das programm oder die funktion verlassen wird. Und letzte Frage: Welche Besonderheit gibt es bei Char zeigern und übergaben? Ich dachte einmal das ich etwas gelesen habe, das irgendwas nicht kopiert wird. Finde es aber nicht mehr oder liege ich da falsch... Es ist das erste mal das ich in diesem Umfang mit Zeigern auf char Variablen arbeite, deswegen die Verständnisprobleme.... Ich fasse zusammen: * malloc verwende ich wenn ich wirklich zeichen innerhalb eines literals ändern will * die char *variable lösung kann ich verwenden wenn ich den Literal nicht editieren will aber vllt. irgendwann mal einen anderen wert in der variable stehen haben will... @ carsten j: habe mal ein kleines beispiel programm geschrieben, aber hier sehe ich das trotzdem die gleiche speicheranfangsadresse verwendet wird. wie meinst du das dann das zeiger auf etwas anderes zeigt? #include "stdafx.h" #include <stdio.h> int main(int argc, char* argv[]) { char *test; test = "test 1"; printf ("1. test char: %s \n",test); printf ("1. Speicherbereich von char: %d \n", &test); test = "test 2"; printf ("2. test char: %s \n",test); printf ("2. Speicherbereich von char: %d \n", &test); return 0; } hier die ausgaben: Danke füre eure Antworten bis hier her

So ein Update. Ich habe ein bischen getestet und folgendes: Bringt einen Speicherzugriffsfehler... ist mir jetzt auch klar warum... kein erklärungsbedarf mehr Gibt mir folgendes aus: Testmessage muhh D.h. ich kann auch test ändern und brauche dazu nicht unbedingt den malloc. Irgendwie bin ich jetzt total konfus. Ich dachte wenn man mit char *test arbeitet ist es eine konstante... Könnte das jetzt mal jemand richtig stellen, wann ich was brauche und warum? Denn ich sehe jetzt ehrlich nicht mehr den Sinn hinter den malloc.... wenn ich auch alles mit char *test machen kann...

So nochmal ich Habe jetzt die Lösung gefunden warum auch mein anfangscode funktioniert hat: char *test; Die Lösung steht hier: http://home.fhtw-berlin.de/~junghans/cref/CONCEPT/string.html Das man ihn dann nicht ändern kann da er zu einer Konstanten wird, ist klar... ansonsten mit malloc arbeiten Noch ne kurze Frage: Beim Übergeben von char Zeigern gibt es doch ne besonderheit? Hab mal was gelesen das etwas kopiert oder auch nicht kopiert wird, finde es blos nicht mehr :-\ Aber einer von euch weiss das doch bestimmt Welche besonderheit hat char? Und noch eins: char *test = "Testmessage"; printf("%s",test); Obiger Beispielcode gibt mir ja "Testmessage" aus. Warum muss ich hier nicht zwingend "printf("%s",*test);" schreiben? Denn so würde doch erst auf den Wert de Speicheradresse verwiesen oder? Oder regelt das die "printf funktion" und sieht das es ein zeiger auf ein Literal ist und interpretiert dann richtig?

Hallo, ich habe die Suche schon benutzt doch leider nichts gefunden, obwohl ich dachte das dieses Thema schon relativ häufig behandelt wurde. Ich suche eine Entwicklungsumgebung für C bzw. C++ (imo programmiere ich aber nur in c) für Linux. Sie sollte syntax-highlighting (ok hat fast jeder text-editor) haben und die möglichkeit zum debuggen bieten. Soll heissen ich kann mitten im Quellcode Breakpoints setzen und dann das Programm schritt für schritt durchdebuggen (wie in Visual Studio 6.0 :beagolisc ) ? Da ich aktuell die Programme auch auf andere Plattformen portieren muss/darf die ggf. den gcc bzw. cc haben würde ich auch gerne die complie-optionen mitsehen. Damit ich es einfach nur 1 zu 1 kopieren kann und dann auf einen anderen OS kompilieren kann. Ich versuche so weit wie möglich c funktionen/methoden zu benutzen die auf jedem OS verfügbar sind. Habe mir schonmal KDevelop angesehen, aber irgendwie komme ich damit nicht so ganz zurecht - ist ein bischen oversized... Was benutzt ihr für Entwicklungsumgebungen?` - Kann auch ruhig etwas kosten

ich weiss das ICH es nicht machen muss. da der compiler das alles selbst regelt solange ich keine alloc kommandos verwende. mich hat es halt nur interessiert

ob das eine byte von char test2[] = ""; freigegeben wird wenn ich es mit der "ungeschickten lösung" *char = "dies ist ein test" mache oder nicht... das war irgendwie unklar...

na bei der array erklärung von guy ist es aber so dargestellt... hier nochma der quote

ok mit malloc ist es natürlich am saubersten Danke.. jetzt hat sich für mich das Mysterium auch geklärt Mit kompletten Platz meinte ich die 509 Zeichen Ja das ist klar.. aber die methode die ich aufrufen will erwatet einen zeiger Und was ist nun mit dem freigeben? Wird er nun freigegeben oder nicht ... Guybrush meinte er wird und Klotzkopp meint nicht

Hi, ok wenn es so ist macht es keinen Sinn... voraussgesetzt der Compiler gibt das 1 Byte für den Leestring nicht mehr frei. Soll heissen. Ich sollte es lieber so machen: char test[]="ich bin eine testvariable"; char *testz = test; richtig? ist zwar umständlicher und nicht so "angenehm". aber wenn der compiler das 1 byte nicht mehr sauber frei gibt... macht es sinn... noch ne kurze frage: gebe ich keine anzahl in der [] an wieviel allokiert er dann? also bei char test[]="ich bin eine testvariable"; nimmt er dann die maximale byte anzahl oder nur die benötigten für die zeichen? danke

Hi, alles klar. wo hast du das mit der warning her? Aber ich kann doch den Inhalt des Speicherbereiches wieder initilaisieren mit test = ""; und wieder neu benutzen?! Wenn etwas drinsteht und ich schreibe drüber ist es klar, das es zu undefinierten verhalten kommen kann. hmmmm im der unix programmierung finde ich aber viele solche beispiele... naja

hallo, mal kurz eine frage zu den variablentyen: char test[20] => dann habe ich ein char array in das ich 20 zeichen stellen kann, jedes zeichen einzel ansprechbar char test => eine variable mit einem zeichen oder? char *test => Zeiger auf Inhalt eines Speicherbereich Wenn ich die variable als zeiger definiere, kann ich ja einen mehr als 1 zeichen in die variable stellen. z.B so:. Und nun die Frage: Wieviel Zeichen kann ich in die Variable test stellen wenn sie vorher als zeiger definiert worden ist? Gibt es da auch ne Begrenzung (bestimmt?!). Danke! Gruß