Printable View
Hello,
I was wondering if it's possible to do something like this in c++, ie. prototype a class:
Obviously the above dosn't work but I hope you understand what I'd like to accomplish here.Code:class ClassName;
int main() {
ClassName test;
return 0;
}
class ClassName {
};
I know you can prototype functions and such but I've been unsuccessfull in doing the same with class definitions.
That's what header files are for.
You can't instantiate a class like that, but you can do something like the following:
Code:class ClassName;
int main() {
ClassName* test;
return 0;
}
class ClassName {
};
Forward declarations for classes are insufficient for creating instances for the simple reason that forward declarations only provide a hint that the class exists somewhere. In order for a class to be instantiated, the compiler needs to know exactly how big the class is, so it needs to have already encountered that class's definition.
As cpjust mentioned, the most common approach is to declare your class in a separate header file to your main program.
Particularly because one of the benefits fo using a class is the code is reuseable. Thats true if its in a header and you canjust use that header in another project. Its not true if its in a cpp file and you have to strip it out to reuse it. Eventually you will end up putting it into a header anyway, so why not just start out doing that.
And unless your writing template classes, you generally only include the class declaration in the header file and put the definition (the actual code) in a .cpp file.
Ex.
Code:// TestClass.h
#ifndef TEST_CLASS_H_INCLUDED
#define TEST_CLASS_H_INCLUDED
class TestClass
{
public:
TestClass();
~TestClass();
const char* GetString() const;
void SetString( const char* str );
private:
char* m_Str;
};
#endif // TEST_CLASS_H_INCLUDED
Code:// TestClass.cpp
#include <cstring>
#include <cassert>
#include "TestClass.h"
TestClass::TestClass()
: m_Str( NULL )
{
// Intentionally left blank.
}
TestClass::~TestClass()
{
delete [] m_Str;
}
const char*
TestClass::GetString() const
{
return m_Str;
}
void
TestClass::SetString( const char* str )
{
assert( str != NULL );
if ( m_Str != NULL )
{
delete [] m_Str;
}
m_Str = new char( strlen( str ) + 1 );
strcpy( m_Str, str );
}
Careful about those forward declarations. While they may be good, they can also scew things up. If the compiler only has a forward declaration when you use the class in your code (pointer to or references to that class are exceptions), the compiler doesn't know anything about the class and can't generate the correct code. For example, it can't call the constructor or destructor.
In your .cpp files, always include the actual header file for the declaration. In header files, when you have functions that take pointers or references to a class, you can get away with using a forward declaration.
I believe the only time you need a forward declaration of a class is when you have two classes that both refer to each other.
Usually, yes (can also happen with circular includes)... but when they do, you get the same above mentioned problem! All references to the forward declared class must be either a pointer or a reference. Otherwise you get problems.
This is probably the only time you need them but it might be a good idea to use them any time you can.Quote:
Originally Posted by cpjust
The idea is to include as few other headers in a header as possible to reduce dependencies between headers. So if a class is only used to declare a pointer or reference in a header, then a forward declaration would be fine.
The real reason I asked this was because I would like to replace the standard main function:
with something like this:Code:int main(int *args, char *argv[]) {
return 0;
}
With a header file:
And the program 'entry point':Code:class Main;
int main(int *args, char *argv[]) {
Main prog(args, argv);
return prog.Start();
}
Where Argument is a class that has already parsed the arguments making them accessible thru a hash table or dictionary.Code:class Main {
public:
Main(int *args, char *argv[]);
int Start() {
/*....*/
return 0;
}
};
The idea was to have the 'real' main function in a header file and the entry point that the programmer would see was instead a class called Main or something like that. Suppose it was a pretty stupid idea to start with anyway.
What you're doing is bad, because you're trying to use the class while it's still undefined (because you're only using a forward declaration telling the compiler it exists).
I should have added that the posted code dosn't work either, it was just how I 'visioned' it.
I settled on something like this instead, skipping the whole class thing:
Code:extern int Main(const Dict<String> &argv);
int main(int args, char *argv[]) {
Dict<String> arguments = ParseArgs(args, argv);
return Main(arguments);
}
Why do you want to do this, though? What's wrong with the initial "main"?
The idea was to 'abstract away' the handling of the arguments, if that makes any sense.Quote:
Originally Posted by Elysia
That's very context specific, how to handle the arguments, is it not?
I thought I'd divide the arguments into key/value pairs, where the seperator is a '=', arguments without assigned values (ie. no '=') would become a key where the value is an empty string. Other then that the arguments would be seperated by whitespace.
For example:
Code:Argument : (key, value)
--------------------------------------------
first=one : ("first", "one")
second = two : ("second", "two")
-p : ("-p", "")
Ah, that makes sense. It's not that bad an idea, really.
You could just make a utility function that parses arguments and returns a std::map, though.
True, but this looks a bit more clean imo. :>.Quote:
Originally Posted by Elysia
EDIT: my suggestion that is :>.