Thread: Code reuse without obfuscation

Hi all -- long time no see,

I have a little C assignment from a training program I'm in. I'm used to C++. My program is essentially two methods in main() that do very similar things to two arrays of structures (different structures). In C++, I could combine these two tasks into one template function, the only fundamental difference being the two different structure types. Is there any way to generalize this code so that it need be expressed only once, or will I do more harm than good? I'm wondering for the sake of C, with which I am not familiar. Here is most of main():

Code:

/* If only C had templates like C++.... */
	/* These two sections of code are similar. */

	/* read stock file */
	stock_file = fopen(argv[1], "r");
	if(stock_file == NULL)
		fopen_abort(argv[1]);
	stock_file_nlines = n_lines(stock_file);
	stocks = (stock*)calloc(stock_file_nlines, sizeof(stock));
	if(stocks == NULL)
		memory_abort();
	n_stocks = read_stocks(stock_file, stocks);
	qsort(stocks, n_stocks, sizeof(stock), stock_cmp);

	/* process trades in trade file */
	trade_file = fopen(argv[2], "r");
	if(trade_file == NULL)
	{
		free(stocks);
		fopen_abort(argv[2]);
	}
	trade_file_nlines = n_lines(trade_file);
	trades = (trade*)calloc(trade_file_nlines, sizeof(trade));
	if(trades == NULL)
		memory_abort();
	n_trades = process_trades(trade_file, trades, stocks, n_stocks);
	qsort(trades, n_trades, sizeof(trade), trade_cmp);

I see how I could consolidate the file-opening and fopen() error checking, but what about the rest?

Thanks.

Well, abstract programming in C is difficult and messy, therefore I advice you not to try it.
Should you tried it though, for the sake of learning , you need a void pointer for the struct and the size of it. You may also consider passing the function an additional "flag" parameter to determine between the two or more. But I say once more that it's difficult and messy!

EDIT: It's error-prone too!

In C there are preprocessor macros. They are not as safe as C++ templates (i.e. it is easier to misuse them) but they can be used to achieve similar things.

Yeah I agree, it should either using macros or sending in by a flag. there is nothing like function overloading in C unfortunately which makes a bit difficult to achieve stuff in C which you perhaps be done quite easily in C++.

ssharish

You repeat 3 things:

1. Opening a file.
2. Counting the lines.
3. Allocating space.

Code:

void *ocalloc( FILE **fp, const char *fname, const char *fmode, size_t membersize )
{
    void *rval = NULL;
    if( fp && fname && fmode )
    {
        *fp = fopen( fname, fmode );
        if( *fp )
        {
            size_t lines = linecounter( *fp );
            rval = calloc( lines, membersize );
        }
    }
    return rval;
}
...
FILE *fp;
type *data;

data = ocalloc( &fp, "myfile", "r", sizeof *data );
if( data == NULL )
    printf( "oops" );

Quzah.

I see. Thank you all.

Originally Posted by CodeMonkey

I'm wondering for the sake of C, with which I am not familiar.

Yes, C involves more work than C++, because it lacks certain temptations, such as templates, which are massive consumers of memory. So, when you are frustrated, think about it this way: how would I approach this in C++ if memory use were a priority and it was spec to NOT use templates?

If you have no answer to that, it's because you've become enamoured of language features which increase programmer productivity, but waste resources. Remember, the soft "C" in C stands for ctreamlined

Originally Posted by anduril462

I would probably take the function pointer approach:

That won't work. From the OP:

read_stocks(stock_file, stocks);
....
n_trades = process_trades(trade_file, trades, stocks, n_stocks);

You can't have a function pointer work for two different functions that have different numbers of arguments - without making the functions something like:

Code:

int foo( x, ... );

I thought of this implementation first, but it seemed too much work for what he was doing, since I could get away with what I did as an alternate.


Quzah.

Originally Posted by MK27

Yes, C involves more work than C++, because it lacks certain temptations, such as templates, which are massive consumers of memory.

Templates are not massive consumers of memory. There was a time when they were (about 15 years ago), but that was a reflection of the quality of implementation of compilers coupled with clumsy usage of templates: both compiler vendors and programmers, at the time, were on a learning curve with what was then a relatively new and complex language feature.