Thread: Classes in a .h file

> 1) First of all, are there any errors in what I wrote up there?
Seems OK to me

> 2) Can I use "MyClass.x ="
No, x is a private variable of the class, which means only functions of the class can access or change it.

This is a cornerstone of OO, where data is encapsulated within the class and hidden from the rest of the world.
This means you always have control over how your internal data is accessed and changed.
It also permits you to change the implementation (say you change int x; to string x;) and the rest of the world need know nothing about that, since InitialiseX() has not changed.

> 3) My main question, can I move the "MyClass::InitialiseX" function dealey into the .h file?
Bad idea, for several reasons
1. You would only be able to include that in ONE .cpp file of your project. This makes it less useful.
The reason being that you would end up with multiple copies of the same code in your executable, and with identical names. The linker would reject this with multiple symbol errors.
2. The interface to your class is the .h file, so you really don't want to be showing how you implemented the inside of the class, just in case someone feels tempted to try something sneaky.
3. The amount of code within a class can be considerable, which would lead to some very bulky header files.
4. If you give your class to someone else, you typically hand over class.h and class.lib (class.lib is the compiled version of class.cpp).

The only time you include real source code inside a header file is if you make that function an inline function. For various reasons, you only want to do that for short functions (typically a couple of lines) which are called very often (say thousands of times per second).

1) Not that I can see... A compiler would be able to give you a more definitive answer.

2) No. The variable 'x' belongs to a specific instance of 'MyClass', and not to the class itself. You can, however, use 'this->x' in non-static member functions, though there is no point as 'x' would do the same thing from within the class.

*edit*
Misinterpreted the second question, I think. If you meant accessing it from outside the class, then no for the reason Salem mentioned. If you meant accessing it from inside the class, then no for the reason I mentioned.

3) Yes, but I would advise against it. In a large project, you can modify your source file, without touching the header file (e.g. to change internal algorithms), and then you would only have to recompile that unit, and relink, instead of recompiling everything that includes your header. The exception is that many compilers require templated functions/classes to be declared and defined in the same file.

In answer to 1:

Code:

class MyClass
{
public:
    InitialiseX(int Number);
private:
    int x;
};

// Needs to be
class MyClass
{
public:
    void InitialiseX(int Number);  // Notice that you need a return type
// Edit: I just checked and it seems like you dont HAVE to have a return type
// But its still good to have one :)
private:
    int x;
};

void MyClass::InitialiseX(int Number) //Make sure this has the right return type as well
{
    x = Number;
}

For Q 2: You cant use something like

Code:

MyClass bla;
bla.x=5;

because you said that x should be private, and therefore only MyClass members can access this and all variables should be kept private, use access functions for them instead.

As for question 3, I think you can have the definition of class-functions in a .h file and then just include that, but Im not sure at all why that isnt good, maybe it has something to do with that you dont compile the definitions...I dunno but its possible (I think).

Also another tip: Indent the code, like I did with your code up there, it will make it so much easier to read.

> Shakti: Is there a trick to indenting?
Yeah, you write the code you want to post in your text editor you use for writing code.

> and if so, would I declare all of these classes in the same .h file (or seperate .h files for each)?
The usual rule is each class has its own .h

> Is there a way to set these up, so that I could do something like:
Here's the basic idea

Code:

class Window {
    Render  Render;
    Input   Input;
};

You need to choose whatever names you want, and decide on how much visibility to give the outside world.

Keep 'em in separate headers. That way, if you change one, you need not recompile the entire thing.

Before you call any non-static member functions of a class, you must first create an instance of the class. Then you can call the functions for that instance of the class:

Code:

class A {
  void f( );
};

int main( )
{
  A obj1;
  // ... or ...
  A* obj2 = new A;

  obj1.f( );
  obj2->f( );

  // And of course, clean up memory from new
  delete obj2;
}

Instances of one class can be member data of another class as well.

Code:

// A.h
class B; // Forward declaration... Definition of B not needed yet.

class A
{
public:
  A(B&);
  void f( );
private:
  B& data;
};

// A.cpp
#include "B.h"

A::A(B& src)
  : data(src)
{
}

void A::f( )
{
  data.do_something( );
}

Well, your missing a semi-colon after your class declaration.

The constructor to be used is determined by what parameters you pass the object when you create it. So, your instantiation should look like this:

Code:

Game MyGame(&MyInstance); // Passed an HINSTANCE*, so thats the constructor it uses.

// Alternatively
Game MyGame2; // Calls the default constructor since you passed no parameters.
// Equivalently...
Game MyGame3( ); // Again, default constructor.