Java programmer having problems with C. - Page 2

#include <stdlib.h>

#define ARRAYSIZE(x) sizeof( x ) / sizeof( x[0] )

typedef struct _NUMBERCOUNT
{
        int* countData;
        int length;

} NUMBERCOUNT, *PNUMBERCOUNT;

void count_numbers( PNUMBERCOUNT ptr, const char* chars, const int length );
void init_numbercount( PNUMBERCOUNT ptr, const int max_number );
void free_numbercount( PNUMBERCOUNT ptr );

int main()
{
        const char chars[7] = "110055";
        const int max = 5;

        NUMBERCOUNT data;
        init_numbercount( &data, max );
        count_numbers( &data, chars, ARRAYSIZE( chars ) );

        int i;
        for ( i = 0; i < data.length; ++i )
                printf( "Total %d's: %d\n", i, data.countData[i] );

        free_numbercount( &data );
        getchar();
        return 0;
}

/* Counts each instance of each number contained in chars */
void count_numbers( PNUMBERCOUNT ptr, const char* chars, const int length )
{
        if ( ptr == nullptr || ptr->countData == nullptr )
                return;

        if ( chars == nullptr )
                return;

        if ( length <= 0 )
                return;

        int i;
        int tmp;

        for ( i = 0; i < length; ++i )
        {
                if ( !chars[i] )
                        continue;

                tmp = chars[i] - '0';
                ptr->countData[tmp]++;
        }
}

/* Initializes _NUMBERCOUNT structure */
void init_numbercount( PNUMBERCOUNT ptr, const int max_number )
{
        if ( ptr == nullptr )
                return;

        if ( max_number <= 0 )
                return;

        ptr->length = max_number + 1;
        ptr->countData = ( int* ) calloc( ptr->length, sizeof( int ) );
}

/* Frees _NUMBERCOUNT structure */
void free_numbercount( PNUMBERCOUNT ptr )
{
        if ( ptr == nullptr )
                return;

        if ( ptr->countData )
                free( ptr->countData );
}

ls -l | a.out

stdin
<cstdio>

FILE * stdin;

Standard input stream
The standard input stream is the default source of data for applications. In most systems, it is usually directed by default to the keyboard.

stdin can be used as an argument for any function that expects an input stream (FILE*) as one of its parameters, like fgets or fscanf.

Although it is commonly assumed that the source of data for stdin is going to be a keyboard, this may not be the case even in regular console systems, 
since stdin can generally be redirected on most operating systems at the time of invoking the application. For example, many systems, among them DOS/Windows
and most UNIX shells, support the following command syntax:

myapplication < example.txt

to use the content of the file example.txt as the primary source of data for myapplication instead of the console keyboard.

It is also possible to redirect stdin to some other source of data from within a program by using the freopen function.

If stdin is known to not refer to an interactive device, the stream is fully buffered. Otherwise, it is library-dependent whether the stream is line 
buffered or not buffered by default (see setvbuf).

FILE
<cstdio>
Object containing information to control a stream
Object type that identifies a stream and contains the information needed to control it, including a pointer to its buffer, its position indicator and all its state indicators.

FILE objects are usually created by a call to either fopen or tmpfile, which both return a pointer to one of these objects.

The content of a FILE object is not meant to be accessed from outside the functions of the <cstdio> and <cwchar> headers; In fact, portable programs shall only use 
them in the form of pointers to identify streams, since for some implementations, even the value of the pointer itself could be significant to identify the stream 
(i.e., the pointer to a copy of a FILE object could be interpreted differently than a pointer to the original).

Its memory allocation is automatically managed: it is allocated by either fopen or tmpfile, and it is the responsibility of the library to free the resources once either the stream has 
been closed using fclose or the program terminates normally.

On inclusion of the <cstdio> header file, three objects of this type are automatically created, and pointers to them are declared: stdin, stdout and stderr, associated with the standard input stream, 
standard output stream and standard error stream, respectively.