C / C++ / MFC

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

CFile
fopen()
CreateFile()
ostream

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

"Ideas are a dime a dozen. People who put them into action are priceless." - Unknown

int main( int argc, char* argv[] )
{
	FILE *fp = fopen( "C:\\Temp\\BigFile.txt", "wt" );
	if( ! fp )
	{
		fprintf( stderr, "Unable to open temporary file\n" );
		return -1;
	}

	int megcount = 0;
	if( argc > 1 )
		megcount = atoi( argv[1] );
	if( megcount < 100 )
		megcount = 100; 

	const __int64 onemeg = 1000000;
	__int64	max = megcount * onemeg;

	fprintf( stdout, "Beginning file writing of %d MB\n", megcount );

	const int writeincr = 20000000;
	int wcount = 0;

	CElapsed et;
	double start = et.Elapsed( 0.0 );

	__int64 total = 0;
	__int64 lines = 0;

	const char *format = 
"0123456789012345678901234567890123456789012345678901234567890123456789012345678901234 line %8I64d\n";
	while( total < max )
	{
		int count = fprintf( fp, format, lines );
		total += (__int64)count;
		wcount += count;
		if( wcount >= writeincr )
		{
			wcount = 0;
			int meg = (int)( total / onemeg );
			double amount = et.Elapsed( start );
			fprintf( stdout, "%4d megabytes have been written : %.1f seconds elapsed\r",
				meg, amount );
		}
		++lines;
	}

	double elapsed = et.Elapsed( start );

	fclose( fp );
	fprintf( stdout, "\n\noutput file has been closed - %I64d lines were written in %.1f seconds\n",
			lines, elapsed );
	return 0;
}

//
// CElapsed.h - header for the CElapsed class
//
//	Copyright 1998-2005 by Rick York
//	This class is free for use in any and all applications for any purpose.
//
//	To use this class include this header and do the following :
//
//	CElapsed timer;	// instantiate a timer object.
//	double start = timer.Elapsed();		// start timing
//	...				// your code here
//	double TimeInSeconds = timer.Elapsed( start);	// obtain elapsed time
//

#ifndef _CELAPSED_H
#define _CELAPSED_H
#else
#error repeated include of this file
#endif

/***
#ifndef _CELAPSED_H
#include "CElapsed.h"
#endif
 ***/


class CElapsed
{
private :
	double	m_Period;
	int		m_Initialized;
	__int64 m_Frequency;

public :
	CElapsed()		// constructor
		{
		// get the frequency of the counter
		m_Initialized = QueryPerformanceFrequency( (LARGE_INTEGER *)&m_Frequency );
		if( ! m_Initialized )
			m_Period = 0.0;
		else
			m_Period = 1.0 / (double)m_Frequency;	// save period of clock
		}

	double Elapsed( double begin=0.0 )	// stop timing and get elapsed time in seconds
		{
		// get the ending counter value
		__int64 endtime;
		QueryPerformanceCounter( (LARGE_INTEGER *)&endtime );

		// convert counts to time in seconds and return it
		double endsecs = endtime * m_Period;
		return endsecs - begin;
		}

	BOOL	Initialized()	// returns true if the perf counter is available
		{ return m_Initialized; }

	__int64	GetFreq()	// return perf counter frequency as large int
		{ return m_Frequency; }

	double	FromMilliSecs( UINT millisecs )
		{ return 0.001 * millisecs; }

	//IMPORTANT!  This is a 'spin loop" delay.  The calling thread hogs the
	// CPU while the delay is in progress and there is less than 1 mS to go.
	// For longer delays than about 3 mS or so use Sleep() which gives up
	// the processor while it waits.

	void Delay( double amount )
		{
			double delta;
			double delaytime;
			double start = Elapsed( 0.0 );
			while( true )
			{
				delaytime = Elapsed( start );
				delta = amount - delaytime;
				if( delta <= 0.0 )
					break;
				if( delta > 0.0012 )	// more than 1mS left
					Sleep( 1 );			// give the CPU a break
			}
		}
};