test

[Brad Jones]

The colour coding is done by msvc not me

This is exactly how it pastes from msvc9 and I swear it doesn't look like that in the compiler.

Code pasted from msvc7.0

#ifndef SEQUENCE_H
#define SEQUENCE_H

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard


Same code pasted from msvc9 express.

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard

[Brad Jones]

The colour coding is done by msvc not me

This is exactly how it pastes from msvc9 and I swear it doesn't look like that in the compiler.

Code pasted from msvc7.0

#ifndef SEQUENCE_H
#define SEQUENCE_H

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard


Same code pasted from msvc9 express.

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard

[Brad Jones]

#ifndef SEQUENCE_H
#define SEQUENCE_H
#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"
namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;
Sequence( const Sequence& );
Sequence& operator =( const Sequence& );
public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}
static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};
} // end namespace
#endif // header guard

[Brad Jones]

#ifndef SEQUENCE_H
#define SEQUENCE_H

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard

[Brad Jones]

#ifndef SEQUENCE_H
#define SEQUENCE_H

#include <algorithm>
#include <ctime>
#include <cstdlib>
#include <cstdio>
#include "typedefs.h"

namespace GT
{
template < uint N >
class Sequence
{
private:
IntVec sequence_;

Sequence( const Sequence& );
Sequence& operator =( const Sequence& );

public:
Sequence()
{
sequence_.reserve( N );
for ( int i = 1; i <= N; ++i )
{
sequence_.push_back( i );
}
Shuffle();
}

const IntVec& GetSequence() const
{
return sequence_;
}

static void Randomize( uint def = 0 )
{
if ( def == 0 )
def = static_cast<uint>( std::time( NULL ) );
std::srand( def );
}

void Shuffle()
{
std::random_shuffle( sequence_.begin(), sequence_.end() );
}
};

} // end namespace

#endif // header guard

[Marie Mih]

And yes, that is English for the UK'er, Aussies and Canadian not American :D
Next time of use, please be careful with the language :D

[Belzeski]

And yes, that is English for the UK'er, Aussies and Canadian not American :D
Next time of use, please be careful with the language :D
I don't know about Brad, I guess Brad is an Australian Canadian man living in Ilionois
Marie - Superstar, you so hillarious :D

[Brad Jones]

And this is what happens when you cut and paste someone else's post and put your own name on it.....

(and I'm in Indiana, not Illinois ;) )