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_;
}
staticvoid 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
Next time of use, please be careful with the language

[Belzeski]

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

I don't know about Brad, I guess Brad is an Australian Canadian man living in Ilionois
Marie - Superstar, you so hillarious

[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 )