Use of 'static' in a class

[h3ro]

What does it mean when a member variable or a member function of a class is static?

// .h file
class example
{
public:
	static int doSomething();	// What does that static mean here?

private:
	static int myVariable;		// What does that static mean here?
}


// .cpp file

// If I dont do this, I get an compiler error. Why do I need to do it?
int example::myVariable;

int example::doSomething()
{
	// Can only acces static member variables. Why?

	return 2;
}

[laserlight]

It means that the member function can be called without an object of the class, and that the member variable can be accessed without an object of the class.

EDIT:
Perhaps Stroustrup's glossary would be more accurate:
static member - member of a class for which there is only one copy for the whole program rather than one per object.

static member function - a member function that need not be called for an object of the class.

[h3ro]

I am working on binding my C++ code to a lua script, and to bind a function the function needs to be "static int something(lua state)"

From what I understand a static is almost like a global, which makes me believe that the following code is not thread safe (I would like it to be thread safe)

// the main program: 
example a;
a.load();
while(for some time)
	a.run();


// example.h file
class example
{
public:
	bool load();
	static int functionToBind();
	void run() const;

private:
	Lua scriptState;
	static VariableCollection myVar;
} 


// example.cpp file

VariableCollection example::myVar;

bool example::load()
{
	// Load and init the lua script state

	// Bind the functionToBind so that it can be called from lua

	return true;
}


static int example::functionToBind()
{
	// use some of the variables in myVar to do some calculations
	// The myVar are different for each instance of the example class

	// Get some info from the script

	// Pass some info that is calculated from myVar to the script
}

void example::run() const
{
	// run a lue script that can call functionToBind
}

[CornedBee]

Indeed it isn't. If you want per-thread state, you'll have to bind it into the Lua context somehow.