Search:

template <size_t s> struct bound;
template <> struct bound<2> { static const unsigned int b = 32767; };
template <> struct bound<4> { static const unsigned int b = 2147483648;...

before calling rand, call srand(time(NULL)) to seed.

i am so wrong it's shocking.

type-o, my bad

can't do that. another idea is to switch on the hash value of a string.

myclass[5] = 7; <- this calls int& operator [](int i);
const int x = myclass[5]; <- this calls const int& operator [](int i) const; (or int operator [](int i) const;)

could you post your code to get a clearer picture of the problem. thanks!

this is about as clear as it gets my friend: (http://en.wikipedia.org/wiki/Insertion_sort)

holy <explative deleted>, that's long! if it works, it works man. bfs = breadth first search (http://en.wikipedia.org/wiki/Breadth-first_search)

how about something like this:


template <typename T>
struct vector_builder
{
vector<T> m_vec;

vector_builder() {}
vector_builder(const T& c) : m_vec(1)

put this both places where you include your c-library. this is by no means elegant, but it'll work.


#if !defined(_include_once_)
# include "c-library.h"
# define _include_once_
#endif

try compiling and running in debug, it might point you to the exact line where the error occurs. (press f5 if you're using VS)

taking the "s -> A, D, G" statement alone. i'm going to assume it means s is adjacent to A, D, and G - so outdegree of 3, and A, D, and G have indegree of 1 each. so take it one step at a time - if...

the second case isn't ambiguous because you're not passing in a const int. the first case is a little trickier. when you pass by const value (func(const int i)), the const is applied to the copy of...

while( i; i != sizeof(out); ++i ){


you probably meant to use a for loop.

i think it is referred to as "the most vexing parse problem", might be worth checking it out. (http://www.gotw.ca/gotw/001.htm)

you can call pthread_join(...) to wait for the threads to finish before destroying the mutex. (http://www.opengroup.org/onlinepubs/007908799/xsh/pthread_join.html)

oh, i'm sorry, i read that as finite. your solution is the right one

there's no need to do the first step, implement a comparison operator where +infinity is always greater than any number and do a bin search on the whole array.

lets say the array is all ints and...

you were trying to call ->image on the pointer to Piece*. if you made the array of Piece objects, the iterator would be a pointer to one of the objects, so you could use -> operator. the way you did...

an iterator is more or less a pointer, in your case it's a pointer to a Piece* (pointer to a pointer), so you need to dereference it to get to the actual Piece*, then you can use the -> operator.

and this is why i didn't disagree with you, but there are, although few, several cases :thumb:

and this:



class X

{
int a;

int b;

no rolls royce can go through rough sand/mud/rocks/water. an 80s Toyota FJ or Land Cruiser can though. pick the right tool for the right job.

and all this time i thought it was a personal preference thing, hmmmm :blush: