C -FAQ

Sprache

Unterschied zwischen "f( void )" und "f()"

Leere runde Klammern in einer Funktionsdeklaration, die keine Funktionsdefinition ist, bedeuten, daß keine Aussage über die Parameter der Funktion gemacht wird. Das sollte aber vermieden werden.

Leere runde Klammern in einer Funktionsdefinition bedeuten, daß die Funktion keine Parameter hat, aber definieren keinen Prototypen, so daß ein Aufruf der Funktion mit Argumenten danach kein Fehler ist (wenn davor kein verträglicher Prototyp definiert wurde).

In C  gilt: “The empty list in a function declarator that is not part of a definition of that function specifies that no information about the number or types of the parameters is supplied.” (ISO/IEC 9899:1999 (E), 6.7.5.3, p14).

Zum Vergleich: in C++  gilt: “If the parameter-declaration-clause is empty, the function takes no arguments.” (ISO/IEC 14882:1998(E), 8.3.5, p2).

Wenn leere runde Klammern in einer Funktionsdefinition  verwendet werden, so scheint dies zunächst zu verlangen, daß die Funktion ohne Argumente aufgerufen wird: “An empty list in a function declarator that is part of a definition of that function specifies that the function has no parameters. ” (6.7.5.3)

Allerdings werden passende Argumente nur für Funktionstypen mit einem Prototyp verlangt: “If the expression that denotes the called function has a type that includes a prototype, the number of arguments shall agree with the number of parameters. Each argument shall have a type such that its value may be assigned to an object with the unqualified version of the type of its corresponding parameter. ” (6.5.2.2 p2)

Leere Klammern definieren aber keinen Prototyp: “A function prototype is a declaration of a function that declares the types of its parameters. ” (6.2.1, p2).

Dateien

Wie kann man die Größe einer Datei ermitteln?

Es ist nicht immer eindeutig, was die „Größe einer Datei“ ist. Die Zahl der Zeichen (Bytes), die aus einer Datei gelesen werden können, kann davon abhängen, ob diese im Text- oder Binärmodus geöffnet wurde. Der Speicherplatzbedarf der Datei, wie er vom Betriebssystem ermittelt wird, kann sich von beidem unterscheiden.

Man könnte auf die Idee kommen, eine Datei als binären Strom zu öffnen, zum Ende zu gehen und die Position zu lesen. ISO/IEC 9899:1999 (E)  sagt in 7.19.3  aber ausdrücklich, daß der Aufruf "fseek( file, 0, SEEK_END )" auf einem binären Strom (und bestimmten anderen) undefiniertes Verhalten hat.

Setting the file position indicator to end-of-file, as with fseek(file, 0, SEEK_END), has undefined behavior for a binary stream (because of possible trailing null characters) or for any stream with state-dependent encoding that does not assuredly end in the initial shift state.

ISO/IEC 9899:1999 (E), 7.19.3, #9, Fußnote 225

A binary stream need not meaningfully support fseek calls with a whence value of SEEK_END.

ISO/IEC 9899:1999 (E), 7.19.9.2, #3

Data read in from a binary stream shall compare equal to the data that were earlier written out to that stream, under the same implementation. Such a stream may, however, have an implementation-defined number of null characters appended to the end of the stream.

ISO/IEC 9899:1999 (E), 7.19.2, #3

Das Öffnen als Textdatei würde es wegen der dann erfolgenden Umwandlungen im allgemeinen aber auch nicht erlauben, die Größe einer Datei zu ermitteln (falls dies nicht gerade so gewünscht ist). Selbst ohne dieses Problem könnte man mit der Funktion "ftell" nur Positionen aus dem Wertebereich des Datentyps "long int" ermitteln.

#include <stdio.h>

long int ftell(FILE *stream);

ISO/IEC 9899:1999 (E), 7.19.9.4, #1

Die Größe einer Datei läßt sich maximal portabel also nur durch Lesen jedes einzelnen Bytes ermitteln (wenn man die Größe als Zahl lesbarer Bytes im Binärmodus definiert).

getc_count

int getc_count( const char * const path, size_t * const result )
{ FILE * input = fopen( path, "rb" );
  size_t size = 0;
  int failed = 1;
  int error = 0;
  int overflow = 0;
  if( input )
  { int ch = getc( input );
    while( ch != EOF ) 
    { if( !++size )overflow = 1, ch = EOF;
      else ch = getc( input ); }
    if( ferror( input ))error = 1;
    if( fclose( input )== 0 && !overflow && !error )failed = 0; }
  *result = size;
  return failed; }

Es ist auch möglich, umgebungsspezifische Funktionen zum Ermitteln der Größe einer Datei zu verwenden. Hierfür könnte eine umgebungsunabhängige Schnittstelle definiert werden, die dann für jede Umgebung implementiert wird, beispielsweise "char * filesize_get( filename_type )". Die Größe der Datei kann dabei als String zurückgegeben werden, weil dadurch keine obere Grenze für die Größe festgelegt werden muß.

Es kann auch überdacht werden, ob für einen bestimmten Zweck die Kenntnis der „Dateigröße“ wirklich nötig ist.

Falls die Dateigröße für eine nachfolgende Operation ermittelt werden soll, muß bedacht werden, daß sie sich nach der Ermittlung verändern könnte, so daß eine einmal ermittelter Wert später möglicherweise nicht mehr die Dateigröße angibt.

(Suchbegriffe: Dateigröße in C ermitteln, c dateigröße ermitteln; c dateigröße bytes ermitteln;)

Strings

Wie kann man eine Zahl in einen String umwandeln?

Man sollte hier nicht von einer Umwandlung sprechen, sondern eher von einer Darstellung einer Zahl als Text. Es gibt keine kanonische Umwandlung einer Zahl in einen Text, da die Darstellung der Zahl als Text von der Wahl eines Zahlensystems und der verwendeten Sprache und Kultur abhängt, die beispielsweise bestimmt, ob ein Dezimalkomma oder ein Dezimalpunkt verwendet wird.

Die Funktion "saldbl" der String-Bibliothek aus dem Anhang, stellt einen Wert des Datentyps "double" als Text dar, der in einer allozierten Zeichenfolge zurückgegeben wird.

Wie kann man einen String als Funktion aufrufen?

Gesucht wird nach einer Möglichkeit, um eine Funktion aufzurufen, wenn der Name dieser Funktion als Text gegeben ist.

Es gibt dafür keine vorgegebene Möglichkeit. In einem übersetzten Programm müssen die Namen von Funktionen des Quellcodes nicht mehr unbedingt vorhanden sein. Wenn die Menge der in Frage kommenden Funktionen bekannt ist, dann können Tabellen verwendet werden, um einem Namen eine Funktion zuzuordnen. Das ist besonders dann einfach, wenn alle in Frage kommenden Funktionen vom gleichen Typ sind.

Das folgenden Programm zeigt, wie eine Funktion aus einer Menge von Funktionen gleichen Typs aufgerufen werden kann, wenn der Name der Funktion als Text (entweder der Text "iota" oder der Text "zeta") gegeben ist.

stringcall.c

/*  
< filename  = [stringcall.c] 
  encoding  = [ANSI_X3.4-1968] 
  notation  = [ISO/IEC 9899:1999 (E)] 
  author    = [Stefan Ram] > */ 
#include <stdio.h>  /* puts   */ 
#include <string.h> /* strcmp */
#define F(r,n,b) r n b 
#define FUNCTIONS \ 
F( void, iota, (){ puts( "Lima" ); } )\ 
F( void, zeta, (){ puts( "Zulu"  ); } )\ 
/**/ 
FUNCTIONS 
#undef F
#define F(r,n,b) n, 
void( * const function[] )() ={ FUNCTIONS }; 
#undef F
#define F(r,n,b) #n, 
char const * const name[] ={ FUNCTIONS }; 
#undef F
int const top = sizeof name / sizeof 0[ name ];
void call( char const * const n ) 
{ for( int i = 0; i < top; ++i ) 
  if( !strcmp( n, i[ name ]))i[ function ](); }
int main( void ){ call( "iota" ); call( "zeta" ); }

stdout

Lima 
Zulu

Die Funktion "call" stellt praktisch einen Interpretierer für eine kleine Sprache mit dem folgenden Startsymbol dar.

〈Start 〉 ::=

"iota" | "zeta".

Um mehr über das Schreiben solcher Programme zu erfahren, kann also die Literatur zum Bau von Interpretierern herangezogen werden.

Wie kann man den Anfang eines Strings erhalten?

Aus der vorderen Teilkette (String ) einer Kette soll eine neue Kette gebildet werden. Beispielsweise soll aus einer Kette die vordere Teilkette vor  dem ersten Auftreten der Teilkette "<OK>" als neue Kette gebildet werden. Hierzu kann die Funktion "salsub" aus der Ketten-Bibliothek des Anhangs verwendet werden.

Unterbrechungen

Wie kann man eine Schleife durch Tastendruck unterbrechen?

Die Programmiersprache C  setzt nicht voraus, daß auf dem Laufzeitsystem überhaupt eine Tastatur vorhanden ist. Deswegen sind auch Zugriffe auf eine Tastatur nicht portabel möglich. Einzelne Implementationen können aber definieren, wie ein Benutzer das Signal "SIGINT" erzeugen kann. Dies könnte dann bei einzelnen Implementationen beispielsweise auch mit einer Tastatureingabe, wie Strg-C, möglich sein.

Das Programm "sigint.c" beendet eine Schleife nach dem Empfang des Signals.

sigint.c

#include  <stdio.h>  /* puts */ 
#include  <signal.h> /* signal, SIGINT, SIG_DFL */
static volatile int looping = 1;
static void h( int const sig ){ looping = 0; }
int main( void )  
{ signal( SIGINT, h ); 
  puts  ( "looping ..." ); 
  while ( looping ); 
  puts  ( "terminated." ); 
  signal( SIGINT, SIG_DFL ); }

stdout

looping ... 
terminated.

(Stichwörter/Suchbegriffe für diesen FAQ -Eintrag: c schleife bis tastendruck)

Anhang

Ketten-Bibliothek

s_type.h

#include <stdlib.h> // free
typedef char * s_type;
/** @brief Make a new string from printf-args.
  @return The new string (allocated) or 0.
  @param f The format string.
  @param ... The rest of the arguments. */
extern s_type salfmt( s_type const f, ... );
/** @brief  Make a new string from a substring. 
  @return The new string (allocated) or 0.
  @param s The start of the substring.
  @param p One past the end of the substring. */
extern char * salsub( char const * const s, 
  char const * const p );
/** @brief Dispose the memory of a string.
  This is used to free (dispose the memory of)
  a string, previously allocated with any sal-function.
  @param s The string to be disposed. */
#ifdef free
void sfree( s_type const r );
#else
inline void sfree( s_type const r ){ free( r ); }
#endif

s_type.c

#include "s_type.h" /* s_type                      */
#include <stdarg.h> /* va_list, va_start, va_end   */
#include <stdio.h>  /* vsnprintf, size_t, vsprintf */
#include <string.h> /* strncpy                     */
#include <stdlib.h> /* malloc, free                */
#include <stddef.h> /* ptrdiff_t                   */
/* nicht getestet! not tested! */
s_type salfmtv( s_type const f, va_list v )
{ va_list a; 
  char * b = 0;
  va_copy(a,v); int const s = vsnprintf( 0, 0, f, a ); va_end(a); 
  if( s >= 0 )
  { size_t const k = 1 + s; if( b = malloc( k ))
    { va_copy(a,v); vsprintf( b, f, a ); va_end(a); }} 
  return b; }
/* nicht getestet! not tested! */
s_type salfmt( s_type const f, ... )
{ va_list a; 
  va_start(a,f);
  s_type const b =  salfmtv( f, a );
  va_end(a);
  return b; }
#ifdef free
void sfree( s_type const r ){ free( r ); }
#endif
char * salsub( char const * const s, 
  char const * const p ) 
{ ptrdiff_t const l = p - s;
  char * const m = malloc( l + 1 );
  if( m ){ strncpy( m, s, l ); m[ l ]= 0; }
  return m; }

s_type_ec.c

/** @file s_type_ec.c
@brief An example client for the allocating string library. */
#include <stdio.h>  /* printf                */
#include <string.h> /* strstr                */
#include "s_type.h" /* salfmt, salsub, sfree */
/** @brief An example client for salfmt.
  @detail It allocates a string containing a formatted
  double value. */
inline s_type saldbl( double const f ){ return salfmt( "%g", f ); }
/** @brief An example client for saldbl.
  @detail It allocates a string containing a formatted
  double value using the function "saldbl", which also is
  defined here in this file.
  Note that we check the result with "if" and release it
  with "sfree".*/
void salfmt_ec( void )
{ double const test = 3.579; s_type const r = saldbl( test );
  if( r ){ printf( "r = \"%s\"\n", r ); sfree( r ); }}
/** @brief An example client for salsub.
  @details It extracts the initial substring of a string s 
  up to (excluding) the first occurence of the
  substring <OK>, so the output is "alpha beta". */
void salsub_ec( void )
{ char const * const s = "alpha beta<OK>xyzzy";
  char const * const w = "<OK>";
  char const * const p = strstr( s, w );
  if( p ){ char * const m = salsub( s, p );
    if( m ){ printf( "%s\n", m ); sfree( m ); }}}
int main( void ){ salfmt_ec(); salsub_ec(); }

stdout

r = "3.579"
alpha beta

Ausgabe des Datums

printdate.c

#include <stdio.h>  /* puts, size_t                */
#include <time.h>   /* strftime, time_t, localtime */
#include <locale.h> /* setlocale, LC_ALL           */
#define SIZE 128
static void print( time_t const date ) 
{ char buff[ SIZE ];
  if( strftime( buff, SIZE, "%A %x", localtime( &date )))
  puts( buff ); }
#undef SIZE
int main( void ){ time_t const date = time( 0 ); 
  setlocale( LC_ALL, "" );
  if( date !=( time_t )-1 )print( date ); }
/* Mittwoch 12.03.03
*/