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?

Nein, nicht nur Literale (also Konstanten im Quellcode) landen als Strings in der ausführbaren Datei. Auch Importsymbole und Debugginginformationen können da stehen.

Ok

Genau. Das ist es, was ich (schon mehrfach) mit statischer Lebensdauer meinte. Literale sind - solange dein Programm läuft - immer da, du brauchst dich um nichts zu kümmern.

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.

Die Frage ist berechtigt. In solchen Fällen sollte die Antwort immer in der Dokumentation der Funktion stehen. Ich zitiere mal aus dem Eintrag in der MSDN Library für inet_ntoa:

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

Der Zeiger zeigt auf eine Konstante, d. h. das, auf was er zeigt, kann nicht verändert werden. Du kannst aber natürlich den Zeiger auf etwas anderes zeigen lassen, was du in deinem Beispiel machst. Wenn du auch das nicht willst, schau dir mal, wie man const einsetzt.

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:

1. test char: test 1

1. Speicherbereich von char: 1245052

2. test char: test 2

2. Speicherbereich von char: 1245052

Press any key to continue

Danke füre eure Antworten bis hier her

So ein Update.

Ich habe ein bischen getestet und folgendes:

char *test = "Testmessage";

printf("%s",*test);

Bringt einen Speicherzugriffsfehler... ist mir jetzt auch klar warum... kein erklärungsbedarf mehr

char *test = "Testmessage \n";

printf("%s",test);

test = "muhh \n";

printf("%s",test);

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

Es muss nirgendwo was freigegeben werden. Nirgendwo. Es sei denn, du benutzt malloc und free, aber das wurde doch schon erklärt. Das Stringliteral wird irgendwo im Binary gespeichert, und bei Abruf wird an die Stelle gesprungen.

Wenn ich mir mein auf Linux produziertes Binärfile angucken (alle Strings extrahiere) sieht das so aus:

/lib/ld-linux.so.2

libc.so.6

printf

_IO_stdin_used

__libc_start_main

__gmon_start__

GLIBC_2.0

PTRh0

QVh<

dieser text steht in einem Array

Dies ist ein Test

Die letzten beiden sind meine Literale, die ich im Quellcode erzeugt habe.

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

Hi,

und was verstehst du jetzt daran nicht?

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...

Da hast du nur einen Zeiger auf ein Literal, da gibt es nichts freizugeben.

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

hier nochma der quote

wird nicht der Leerstring überschrieben, sondern es wird ein neuer String vom Compiler angelegt und test verweist nun darauf. Also sowas in der Art:

char *test;

char test2[] = "";

test = test2;

char test3[] = "test";

test = test3;

Ich hab mich etwas undeutlich ausgedrückt. Ich meinte nicht genau sowas, sondern etwas ähnliches. Das Beispiel sollte dazu dienen zu verdeutlichen das es jedesmal verschiedene Speicherbereiche sind auf die test zeigt.

@sayso

Es wird automatisch beim Beenden des Programms bzw beim verlassen der Funktion freigegeben wenn du sowas machst:

char test[] = "test";

[/PHP]

nur wenn du dir selber Speicher reservierst, mit malloc, calloc oder sonstwas dann musst du den selber wieder freigeben.

ok aber was ist mit der char *test = "dies ist ein test" lösung/möglichkeit?

Wird es das byte nun freigegeben oder nicht?

doch der Speicher würde freigegeben werden weil dieser auf dem Stack angelegt wird. Ich hab dir aber oben noch ein Beispiel mit angefügt.

Nur die benötigten. Die maximal Verfügbaren wäre dein kompletter Speicherplatz

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

Solange dir klar ist, dass testz jetzt auf das Array test zeigt. Kopiert wird da nichts, wenn du testz änderst, änderst du auch test. Immerhin darfst du das.

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

Nein, du hast das Zeigerprinzip nicht richtig verstanden.

Ein Zeiger ist immer 4 Byte groß (zumindest auf einem 32Bit System) und enthält nur eine Adresse, das ist alles.

Wenn du nun sowas machst:

char *test="";

[/PHP]

Wird meiner Einschätzung nach vom Compiler irgendwo fest Speicher reserviert um einfach einen Leerstring aufzunehmen, also eine binäre 0.

Also im Prinzip wieder so was:

[PHP]
char *test;
char test2[] = "";
test = test2;

Das heißt du hast einmal 4 Byte für den Zeiger belegt und einmal 1 Byte für den Leerstring.

Machst du nun sowas:

test = "test";

[/PHP]

wird nicht der Leerstring überschrieben, sondern es wird ein neuer String vom Compiler angelegt und test verweist nun darauf. Also sowas in der Art:

[PHP]
char *test;
char test2[] = "";
test = test2;
char test3[] = "test";
test = test3;

D.h. du hast jetzt die 4 Byte für den Zeiger, 1 Byte für den Leerstring und 5 Byte für den andere String belegt.

Ich hoffe das es dadurch etwas klarer wird, das es keinen Sinn macht Zeiger so zu benutzen.

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

Hallo,

ja:

warning: string length `600' is greater than the length `509' ISO C89 compilers are required to support

Du darfst den String aber nicht verändern, weil das undefiniertes Verhalten erzeugt. D. h. was einmal da drin steht, steht drin, für den Rest des Programms.

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

Ich persöhnlich würde dir aber nicht empfehlen das so wie du es gemacht hast zu machen

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:.

char *test = "";

test = "ich bin eine testvariable";.

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ß