brx

This is not possible in C++. Classes in C++ are no objects and therefore it is not possible to store them in a variable. It is possible in different languages (e.g. Java, Smalltalk...).

What problem are you trying to solve with this? Looks to me like you want to implement some kind of factory pattern with this?!

I just remembered that I read, that the C++11 std::atomic feature deals with instruction reordering. However, I have never used it and can't say anything about it. If you do have a C++11 compiler the std::thread and std::mutex classes should be all you need anyways.

Less error prone is the usage of std::async and std::future, however, from what you wrote so far your use-case seems to fall out of the scope of those two.

When processing the file, you read it line by line.
You get the first line. It contains /NAME/ and your code correctly replaces it and gives the desired output.
Now the next line is read. From what you posted it is an empty line. So your call to
line.find("/N")
will return string::npos. Same for
line.find("E/")
which is then passed to replace and causes the access out of bounds. Check the return values of your find calls and do not call replace if one of them is equal to string::npos.

From what Adam_42 wrote, I assume the problem is the emit keyword of Qt. The Qt documentation suggests this workaround: http://developer.qt.nokia.com/doc/qt-4.8/signalsandslots.html#using-qt-with-3rd-party-signals-and-slots

EDIT:
I have modified all the code with vector.push_back like this:

Particle a(xx, yy, 6);
v_particles.push_back(a);
a.~Particle();

Do not call destructors explicitly except when you REALLY know what you are doing. Read this: http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.5

Actually, I do not see any way that one of the lines you posted could cause a memory leak (except when one of your classes allocates memory inside its contructor that is not freed in the destructor). Since you are not constructing objects on the heap using new, all objects cou create are created on the stack. Those will be deleted automatically when they go out of scope. The vector itself stores copies of your object:

Particle a(xx, yy, 6);  // creates a new Particle object on the STACK
v_particles.push_back(a); // creates a new Particle object inside push_back and uses the copy constructor of Particle to do so.

In order to find memory leaks you should look into tools that do that for you, e.g. valgrind.

No problem, glad I could help.

One thing I forgot to mention are that there are different ways of passing arguments in C++. I recommend you look up "pass by value/reference/pointer". In the example I wrote the Player object is passed by reference (noted by the '&').

I have the feeling that there is some kind of misunderstanding about the Class/Object concept. You call methods (functions) on objects not on classes. Classes are only a definition of what an object can do (at least in C++, in other languages classes themselves are objects as well, but that doesn't matter right now). So if you call the Player::getXPosition() method you need an instance (object) of the Player class.

As you did not post any code, I assume you are doing something like this (very very simplified, but I hope you'll get the picture):

// main
int main(int argc, char** argv) {
  Player p;
  p.SetXPosition(5);
  int playerX = p.GetXPosition(); // returns 5
  // more code. ...
}

// somewhere in your Bullet class
void Bullet::someMethod() {
  Player p;  // creates a new instance of the class Player totally unrelated to the one created in your main method
  int playerX = p.GetXPosition(); // returns the default value for x (apparently 0)
  // more code ....
}

So what you need to pass to the method in Bullet that is supposed to use the Player object is the actual instance of the Player class. E.g.:

void Bullet::someMethod(Player& p) {
  int playerX = p.GetXPosition(); // returns whatever the player's x position was set to outside
  // more code...
}

Going back to your main function it may look like this:

// main
int main(int argc, char** argv) {
  Player p;
  p.SetXPosition(5);
  Bullet b;
  b.someMethod(p); // will use the Player object with X position set to 5
}

We have the same method in our code and it is not optimized away (neither in visual studio nor gcc).

Just to be sure: do a little test project where you force a number to be nan (e.g. sqrt(-1) should produce nan, I think). Apply your nan check and have different output based on the result. Compile with full optimization and check the results.

Actually, Java even offers to take over the whole management of the thread pool: java.util.concurrent.Executors. This way you don't need to manage the sleeping and waking up of the threads yourself.

Example:

class Pathfinder implements Runnable {
  @Override
  public run() {
	// pathfinding stuff
  }
}

// A simple ThreadFactory class (note that it will only be used when no more threads are available:
public class SimpleThreadFactory implements java.util.concurrent.ThreadFactory {   
	@Override
	public Thread newThread(Runnable r) {
		return new Thread(r);
	}
}

// initializing the thread pool (the executor):
ExecutorService mThreadPool = Executors.newFixedThreadPool(mThreadPoolSize, new FSshThreadFactory());

// starting a new pathfinder:
Pathfinder pf = new Pathfinder();
mThreadPool.execute(pf);

Use forward declarations.

In your code, the SphereClass header does not need the full definition of SceneClass since you only use pointers to SceneClass. Just replace the line

#include "SceneClass.h"

with

class SceneClass;

and move the include to the cpp file and you should be fine.

Note that in your case it would not work the other way around, because the SceneClass header actually uses the  SphereInfoStruct as a template parameter of the vector.

Or run the debug version without an attached debugger (ctrl+f5)

Another way would be to use OutputDebugStr() for all your output.

On 64 Bit Windows there are two "Program Files" directories, one for 32 bit apps and one for 64 bit apps. VS is a 32 bit app (event though it has 64 bit compilers). You should find the .bat file you are looking for in: C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\vcvarsall.bat


EDIT:

No,  but I gave in and opened up the IDE as edd mentioned and got a command  prompt that was configured correctly.  I tried a dir /s *.bat  from  \program files\microsoft visual studio 10.0 but haven't found  anything so I assume they want people to start using the IDE.  Give me a  command line or give me death.

Actually, you didn't even need to open the IDE which is also not what  edd said. Go to start menu->All programs->Microsoft Visual Studio  2010->Visual Studio Tools. Now chose the command prompt you'd like  (x86/amd64/itanium). This is, of course, only a link to the .bat file I mentioned before.

Additional information why such a conversion is illegal can be found here: http://www.parashift.com/c++-faq-lite/proper-inheritance.html#faq-21.2