Strings zurückgeben

31/03/2009 - 00:23 von Tom Seidel | Report spam
Hi!

Ich hàtte mal eine Frage, wie man folgendes sauber in C löst bzw. ob es dazu
irgendetwas idiomatisches dazu gibt: Geg. ist eine Funktion, die als
Argument einen Pointer auf char bekommt. Mit diesem String wird dann
innerhalb der Funktion ein wenig rumgespielt und der nun neue STring soll
zurückgegeben werden:

Bisher habe ich das immer so gemacht:

char *myfunc(char *str) {
char *res = malloc(10 * sizeof(char));

//...
return res;
}

Der Aufruf erfolgte dann über:

char *my_func_res;
//...
my_func_res = myfunc("PARAM1");
free(my_func_res);

Ist das nun die einzige Möglichkeit oder gibt es noch andere? Versucht habe
ich auch schon mal in der Funktion myfunc() res als Buffer zu definieren,
was jedoch nicht funktioniert, da dann der Compiler meckert.

Danke für eure Antworten!
 

Lesen sie die antworten

#1 ram
31/03/2009 - 00:46 | Warnen spam
Tom Seidel writes:
Ist das nun die einzige Möglichkeit oder gibt es noch andere?



Der Wert von »malloc(...)« wird in dem von Dir gepostetem
Programm anscheinend auch dann verwendet wird, wenn er 0 ist.

Ich mach das beispielsweise so:

/** @file mstrd.c
@brief convert a number to an allocated string.
@author Stefan Ram */

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

/// make string from double.
/** This will convert a double value to a string
* representation.
* @param d the double to convert from
* @param f the format (for snprintf)
* @param c the locale to be used
* @return an allocated string or 0
*/
char * mstrd( double const d, char const * const f,
char const * const c )
{ char * b = 0; setlocale( LC_ALL, c );
int const s = snprintf( 0, 0, f, d );
if( s >= 0 ){ size_t k = 1 + s;
if( b = malloc( k ))snprintf( b, k, f, d ); }
return b; }

/// example use of mstrd.
int main()
{ char const * const r = mstrd( 2.5, "%.2f", "" ); if( r )
{ printf( "r = \"%s\"", r ); free(( char * )r ); }}

/* stdout:
r = "2.50" */

Der Besitz an dem potentiellen Puffer wird von »mstrd« an
»main« übergeben. »main« verwendet diesen genau dann, wenn er
nicht 0 ist und gibt den Besitz genau dann mit »free« an die
Umgebung zurück.

(Daß der Besitz an den Aufrufer übergeben wird, sollte in der
Dokumentation von »mstrd« noch deutlicher stehen als oben.)

Für viele Programmierer ist es die richtige Lösung, eine
andere Sprache als C zu wàhlen.

»There were two versions of it, one in Lisp and one in
C++. The display subsystem of the Lisp version was faster.
There were various reasons, but an important one was GC:
the C++ code copied a lot of buffers because they got
passed around in fairly complex ways, so it could be quite
difficult to know when one could be deallocated. To avoid
that problem, the C++ programmers just copied. The Lisp
was GCed, so the Lisp programmers never had to worry about
it; they just passed the buffers around, which reduced
both memory use and CPU cycles spent copying.«

<XNOkd.7720$

»A lot of us thought in the 1990s that the big battle
would be between procedural and object oriented
programming, and we thought that object oriented
programming would provide a big boost in programmer
productivity. I thought that, too. Some people still think
that. It turns out we were wrong. Object oriented
programming is handy dandy, but it's not really the
productivity booster that was promised. The real
significant productivity advance we've had in programming
has been from languages which manage memory for you
automatically.«

http://www.joelonsoftware.com/articles/APIWar.html

Ähnliche fragen