Thread: Use of a class in place of main( )?

This is something I've toyed with in the past, but only recently considered using on a regular basis. I'll post a working example of some current brainstorm sessions, but until then, Id' like to know what you guys think about this approach?

What exactly do you have in mind? You would still need the main function, methinks.

You could just do what some libraries do and hide main() with a macro. Or just use Java.

Originally Posted by EVOEx

Now, you'd like to completely remove main? That would only make the code less portable, as you'd have to write your own compiler or edit an open source compiler to load it. And just one single function in any file that does the same keeps it portable and readable.

It wouldn't require any compiler rewrites... After all the Linux kernel is written in C, has no main() function, and doesn't require a special compiler.

main() is just a part of standard C/C++. The C/C++ runtime calls it after initialization. With some adjustments to the runtime, some other function could be called (probably a static method of some class, like in Java). Not that I see any point in doing it.

Originally Posted by EVOEx

I think it's quite good to have as little code as possible outside of classes.

A little off topic, but I suggest that you read:
How Non-Member Functions Improve Encapsulation
GotW #84: Monoliths "Unstrung"
Designing Simple Interfaces

O.K., so for example:

Code:

namespace xtd {

namespace impl_ {

struct application_base
{
    application_base( void )
    {
        if( singleton )
            throw;
        singleton = this;
    }
    
    virtual int
    entry_point( char**, char** ) = 0;
            
    static application_base*
        singleton;
};    

application_base*
    application_base::singleton = 0;

} // namespace impl_
    
template < typename Derived >    
struct application : public impl_::application_base
{
    template < typename Pointer >
    Pointer
    sentinal_end( Pointer ptr )
    {
        while( *ptr )
            ++ptr;
        return ptr;
    }
    
    template < typename P1, typename P2, typename P3, typename A1, typename A2, typename A3 >
    int
    main_dispatcher( int ( Derived::* )( P1, P2, P3 ), A1 a1, A2 a2, A3 a3 )
    {
        return  ( ( Derived* )this )->main( a1, a2, a3 );
    }    
    
    template < typename P1, typename P2, typename A1, typename A2, typename A3 >
    int
    main_dispatcher( int ( Derived::* )( P1, P2 ), A1 a1, A2 a2, A3 a3 )
    {
        ( ( Derived* )this )->main( a2, a3 );
    }    
    
    template < typename P1, typename A1, typename A2, typename A3 >
    int
    main_dispatcher( int ( Derived::* )( P1 ), A1 a1, A2 a2, A3 a3 )
    {
        return  ( ( Derived* )this )->main( a2 );
    }
    
    template < typename A1, typename A2, typename A3 >
    int
    main_dispatcher( int ( Derived::* )( void ), A1 a1, A2 a2, A3 a3 )
    {
        return  ( ( Derived* )this )->main( );
    }    
    
    int
    entry_point( char** argv, char** envp )
    {
        typename Derived::strings
            command_line( argv + 1, sentinal_end( argv + 1 ) ), 
            environment_variables( envp, sentinal_end( envp ) );
        return main_dispatcher( &Derived::main, argv[ 0 ], command_line, environment_variables );
    }    
};
    
} // namespace xtd

int
main( int argc, char** argv, char** envp )
{            
    if( !xtd::impl_::application_base::singleton )
        throw;
    return xtd::impl_::application_base::singleton->entry_point( argv, envp );
}

And then instantiate like:

Code:

#include <iostream>
#include <vector>

using namespace std;

struct application : xtd::application< application >
{
    typedef vector< string >
        strings;
    int
    main( string const& name, strings const& commands, strings const& environment )
    {
        cout << "Application: " << name << endl;
                if( !commands.empty( ) )
                {
            cout << "- Command Line -" << endl;
                        for( int i = 0, n = commands.size( ); i < n; i++ )
                cout << i << ") " << commands[ i ] << endl;
        }
                if( !environment.empty( ) )
                {
            cout << "- Environment Variables -" << endl;
                        for( int i = 0, n = environment.size( ); i < n; i++ )
                cout << i << ") " << environment[ i ] << endl;
        }        
    }
}
    instance;

So you want to turn C++ into Java?? Why?
Stand-alone functions have a useful purpose. Forcing people to put everything into a class, whether it needs to be there or not is just stupid.

>> What does this buy you?

Good question. First of all, it makes support for multiple platforms more seamless. You could define a WinMain function, for instance, and a simple change of linker options would be all that would be needed to convert to a Win32 executable. Customization of the format of command-line and environment-variables makes processing program data more straightforward. Putting everything in a class effectively places all of the code into a private namespace, and simplifies the initialization and access of data that would normally be declared as global variables. Those are the most obvious benefits, but there are other aesthetic and practical reasons for doing things this way. It's interesting that most of the objections I've heard so far seem to be based on the fear of the unfamiliar or unorthodox. I have yet to hear a truly compelling reason why this sort of paradigm should *not* be used...

Originally Posted by whiteflags

This seems rather repetitious given the other replies, but, C++ is supposed to be a generic programming language. While main as the entry point is a holdover from C, I don't think that you could create something substantially different (like a System class or whatever you call it) and still claim C++ to be a generic programming language. Imagine how annoying it is to use functional decomposition to solve a particular problem and then have to instantiate some class to get it to work.

There's probably something you could do, but is that different from just using Java?

C++ is not supposed to be a generic programming language. It is not supposed to be a programming language with only one paradigm at all.
It is supposed to be a multi-paradigm language! Generic programming may be a big part and one of its strengths, but that does not make C++ a generic programming language...