Thread: understanding sscanf() function

1) Using fflush() on any input stream gives undefined behaviour, regardless of whether you are using scanf() ot fgets(). In short, don't use fflush(stdin) - ever.

2) Yes, a common use case is to employ fgets() to read a string, and sscanf() to scan the received string. There is no linkage of any buffer to fgets() or sscanf() in doing so (at least, no more linkage than is implied by fgets() reading characters to an array, and sscanf() to interpret the data that fgets() places there).

3) The * modifier on a format means to discard data, rather than write it to a subsequent argument. So, %*s means act as if %s was used, but discard the string rather than writing it.

So, in that link

Code:

sscanf (sentence,"%s %*s %d",str,&i);

is equivalent to

Code:

sscanf(sentence, %s %s %d, str, buffer_to_discard, &i);

if we assume that buffer_to_discard is an array of char large enough to hold the results of the second %s format. The advantage of %*s is that it discards the second string, without having to mess around trying to estimate its length (or worry about chaos that might ensue from a buffer overflow if buffer_to_discard is too short).

Note: the return value from the second sscanf() call will be different than the first, but the code you linked to is not checking the return value anyway.

Your question is too general. Not all styles of input suited to the fgets()/scanf() sequence.

You need to decide how you will skip over characters that do not form an integral value, and then extract the integral value. Maybe that will involve sscanf(). Maybe it won't.

Without a concrete specification of what input you expect (and how the input might vary) it is not possible to give a solution. If you give that specification then, maybe, someone will offer a solution (which might or might not involve using sscanf()). Without that specification, you're essentially asking for a general solution where none exists.

Originally Posted by ak47

however sscanf() is only useful if i know the exact contents of the buffer array.In many real time situations i may not know the exact contents of that buffer array,all i do know that it will contain only one number(int) every time

Can you give examples of what you mean by "it will contain only one number every time". When you use fgets, you read an entire line. When you use sscanf you can get integers or whatever else from that line. It doesn't matter what the "index position" of where the integers appear on that line.

All sorts of ways, but a single sscanf() call won't be an effective solution, since the buffer_array is not a fixed format.

One way of skinning this cat is;

Code:

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

const char *step_over(const char *buffer_array, const char *substring)
{
     buffer_array = strstr(buffer_array, substring);
     if (buffer_array)
     {
          buffer_array += strlen(substring);
          if (!*buffer_array) buffer_array = NULL;
     }
     return buffer_array;
}

int extract_int(const char *buffer_array)
{
    //   assume buffer_array is not NULL and contains a zero terminated string (e.g. a string literal)
    do
    {
         int a;
         buffer_array = step_over(buffer_array, "error code ");
         if (buffer_array && sscanf(buffer_array, "%d", &a) == 1) return a;      /* we have found an int immediately following the string "error code " */
   } while (buffer_array && *buffer_array);

   return 0;    /*  integral value of interest not found  */
}

I am assuming you're happy to discard the strings like "NULL" and "STOP". Note this code also ignores other extraneous digits (e.g. the '1' in "operation1").


Incidentally, if you are using fgets() to read your data, you will not typically be passing byte arrays in the format you describe. fgets() extracts only one line at a time (or a partial string if the buffer is insufficient). It does not pass strings containing multiple carriage returns. The code could be made simpler by assuming no more than a single line is passed (but would also need to cope with partial lines).