Problem mit char*

Fishmac

Hallo Leute,

bin ein Newbie hier im Forum und hab schon das erste Problemchen:

Ich möchte eine Zeichkette beliebiger Länge verwalten in C.
Nun hab ich hierfür folgendes gemacht:

int laenge = 12, idx;
char *zeichenkette;
char c = 'X';

zeichenkette = malloc(laenge*(sizeof(char));

for (idx=0;idx<laenge;idx++){
 zeichenkette[idx] = c;
}

wenn ich nun mit

printf("%s\n",zeichenkette);

die Zeichenkette ausgeben will, klappt das zwar, aber ich bekomme die ausgabe
XXXXXXXXXXXX²²²²

Muss ich den Alloziierten Speicherbereich erst noch initialisieren?

Vielen Dank schon mal
Fishmac

feigling

Du musst das \0 am Ende vom String beachten.

proggingmania

Hi !
Du musst ein Byte für das '\0' Zeichen übrig lassen.
Damit wird die Zeichenkette korrekt abgeschlossen.

Fishmac

In wie fern?

Hab grad eine andere Idee bekommen, ist vielleicht sowas möglich:

for (idx = 0; idx<laenge; idx++){
 ++zeichenkette=c;
}

???????

Fishmac

proggingmania schrieb:

Hi !
Du musst ein Byte für das '\0' Zeichen übrig lassen.
Damit wird die Zeichenkette korrekt abgeschlossen.

Also sowas wie

malloc((laenge+1)*(sizeof(char)));

????

proggingmania

Ja, aber auch das '\0' reinschreiben:

#include <stdio.h>
#include <stdlib.h>

void main( void )
{
	  int chars = 12, i;
	  char *zk;

	zk = malloc( ( chars + 1 ) * sizeof(char) );
	if ( !zk ) return;

	for ( i = 0; i < chars; i++ )
	{
		zk[i] = 'Y';
	}

	puts(zk);		// Kagge
	zk[i] = '\0';	// !
	puts(zk);		// Ok

	free( zk );     // ;-)
}

Und free nicht vergessen

Fishmac

Super, danke.

Werd es heute Abend auf meinem Rechner gleich mal testen..

Was meinst du mit //Kagge ?
Sollte ich also vorher das '\0' einfügen und dann erst puts(zk) machen?

proggingmania

Fishmac schrieb:

Sollte ich also vorher das '\0' einfügen und dann erst puts(zk) machen?

FinalbrainXP

Was auch ganz gut geht, ist mit memset den String gleich komplett auf 0 zu setzen.
Das hat den Vorteil, dass wenn man den String nur zu hälfte füllen möchte, auch nur die Hälfte ausgegeben wird, ohne sich später um das terminierende Nullzeichen
zu kümmern.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void main(void)
{
	int laenge = 12, idx;
	char *zeichenkette =(char *) malloc((laenge+1)*(sizeof(char)));

	memset(zeichenkette,0,sizeof(char)*(laenge+1));

	for (idx=0;idx<laenge;idx++)
		zeichenkette[idx] = 'X';

	printf("%s",zeichenkette);

	free(zeichenkette);
}

Fishmac

Super, vielen Dank.

Ich denke, hiermit ist das Thema erledigt !

CStoll

FinalbrainXP schrieb:

Was auch ganz gut geht, ist mit memset den String gleich komplett auf 0 zu setzen.
Das hat den Vorteil, dass wenn man den String nur zu hälfte füllen möchte, auch nur die Hälfte ausgegeben wird, ohne sich später um das terminierende Nullzeichen
zu kümmern.

Und sogar das kann man noch verkürzen, indem man gleich calloc() verwendet (das fasst die Aufrufe malloc() und memset() zusammen):

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int main(void)//bitte korrekten Rückgabetyp verwenden
{
    int laenge = 12, idx;
    char *zeichenkette = calloc((laenge+1),1);
    //der Rückgabewert von malloc und Co sollte nicht gecastet werden
    //und sizeof(char) ist IMMER 1

    for (idx=0;idx<laenge;idx++)
        zeichenkette[idx] = 'X';

    printf("%s",zeichenkette);

    free(zeichenkette);
}

FinalbrainXP

kuhl, calloc kannte ich nicht. Praktisch zu wissen

@sizeof(Char) ist immer 1, ja da hast du Recht
@Rückgabetyp, jep war nen Fehler.

Aber wenn ich den Cast weglasse bekomme ich eine Warnmeldung ?

/edit:

Ahh..ok..hab den Grund verstanden..das ist der Nachteil wenn man ein wenig mixed C/C++ Proggt^^

casting is where you (the programmer) decide that you know better than the compiler.

So when you say this
(char*)malloc(10)

You're saying that you take whatever malloc returns, convert it to a char*, and assign that to the variable in question.

This is all well and good if malloc is prototyped properly (by including stdlib.h), where it's defined as returning void*.

The problem comes in when you fail to include stdlib.h, and the compiler initially assumes that malloc returns an int. The real problem is, you DONT get any warning from the compiler.

You merrily then convert that int to a char* (via the cast). On machines where sizeof(char*) is different from sizeof(int), the code is seriously broken.

Now if you just have
char *var = malloc( 10 );
And you miss out the include <stdlib.h>, you will get a warning from the compiler.

http://www.eskimo.com/~scs/C-faq/s7.html