Как на чистом Си реализовать таймер?

TimeCounter timer;
timer.Start();
....
timer.Stop();
std::cout << timer;

код

// TimeCounter.h

#ifndef __TIMECOUNTER222__H__
#define __TIMECOUNTER222__H__

#include <iostream>

// #include <cassert>

//////////////////////////////////////////
/// Допустимые значения приоритета потока:
/// THREAD_PRIORITY_HIGHEST
/// THREAD_PRIORITY_ABOVE_NORMAL
/// THREAD_PRIORITY_NORMAL
/// THREAD_PRIORITY_BELOW_NORMAL
/// THREAD_PRIORITY_LOWEST
//////////////////////////////////////////

class TimeCounter
{
friend std::ostream& operator<<(std::ostream& out, TimeCounter& cntr);
public:

TimeCounter() {started=false; stopped=false;}
void Start();
void Start(int nPriority);
void Stop();
double timeElapsed() const;
bool getStarted() const {return started;}
bool getStopped() const {return stopped;}
int getNewPriority() const {return new_priority;}
~TimeCounter();

protected:

int new_priority;
int old_priority;
bool started;
bool stopped;
double tBefore, tAfter, i64PerfFrequency;
double tWord;

};

#endif

TimeCounter.cpp-------------------------------------------------------------------------------------------
Код:
#include "stdafx.h"
#include "TimeCounter.h"
#include <windows.h>

void TimeCounter::Start()
{
// assert(!started);
started=true;
stopped=false;
new_priority=0;

LARGE_INTEGER pf;
QueryPerformanceFrequency(&pf);
i64PerfFrequency = pf.QuadPart;
Sleep(0);
QueryPerformanceCounter(&pf);
tBefore = pf.QuadPart;
}

void TimeCounter::Start(int nPriority)
{
// assert(!started);
started=true;
stopped=false;
new_priority=nPriority;
old_priority=GetThreadPriority(GetCurrentThread());
SetThreadPriority(GetCurrentThread(),new_priority);

LARGE_INTEGER pf;
QueryPerformanceFrequency(&pf);
i64PerfFrequency = pf.QuadPart;
Sleep(0);
QueryPerformanceCounter(&pf);
tBefore = pf.QuadPart;
}

void TimeCounter::Stop()
{
// assert(started);
LARGE_INTEGER tAfter1;
QueryPerformanceCounter(&tAfter1);
tAfter = tAfter1.QuadPart;

tWord = tAfter - tBefore;
tWord /= i64PerfFrequency;
if (new_priority)
SetThreadPriority(GetCurrentThread(),old_priority);
started=false;
stopped=true;
}

double TimeCounter::timeElapsed() const
{
LARGE_INTEGER tempAfter;
double tempWord;

if (started)
{
QueryPerformanceCounter(&tempAfter);
tempWord = tempAfter.QuadPart - tBefore;
tempWord /= i64PerfFrequency;

return tempWord;
}
if (stopped)
return tWord;

return 0.;
}

TimeCounter::~TimeCounter()
{
if (new_priority)
SetThreadPriority(GetCurrentThread(),old_priority);
}

std::ostream& operator<<(std::ostream& out, TimeCounter& cntr)
{
double fsec = cntr.timeElapsed();
int hour = int(fsec/3600.);
double fmin = fsec-3600.*double(hour);
int min = int(fmin/60.);
double sec = fmin-60.*double(min);
out<<"Time elapsed: "<

Без WinAPI функций тебе не обойтись, т. к. таймер уже системная фигны.

Ну или ты можешь делать цикл, типа

while()
{
Sleep();
}

Но это такой псевдо таймер.