Nsryjdtyk

I am trying to create a class that defines an array of command structs, each of which has two CHAR variables, one CHAR*, one INT and a pointer to a void function that accepts two CHAR arguments. There will be multiple instances of this array, each in a different class. I feel like I am close, but missing something critical. The Arduino GNU compiler seems to agree that I am missing something. Here's the code (with modifications as per Bo R);

<<<<<<<<<< Commands.h >>>>>>>>>>>>>>>>>



#pragma once

//template <class T>

class Commands {

public:

    typedef void ( Commands::*FunctionPointer )( char, char );



    struct command {

        char sel;

        char act;

        char const *desc;

        FunctionPointer funcPtr;

    };



    command myCommands [2] = {

        command { 'a','?',"FOO", &Commands::foo },

        command { 'b','x',"BAR", &Commands::bar },

    };



    int cmdSize = sizeof ( myCommands ) / sizeof ( myCommands [0] );



    void foo ( char sel, char act ) {

        show ( { sel }, { act } );

    }



    void bar ( char sel, char act ) {

        show ( { sel }, { act } );

    }



    void show ( char sel, char act ) {

        Serial.print ( "SEL = " );

        Serial.print ( sel );

        Serial.print ( " ACT = " );

        Serial.println ( act );

    }



    void execute ( char sel, char act ) {

        for (int i = 0; i < cmdSize; i++) {

            if (myCommands [i].sel == sel && myCommands [i].act == act) {

                Serial.println ( myCommands [i].desc );

                ( this->*myCommands [i].funcPtr )( sel, act );

                return;

            }

        }

        Serial.print ( F ( "Unknown SEL/ACT Pair:" ) );

        Serial.print ( sel );

        Serial.print ( '/' );

        Serial.println ( act );

    }

};





<<<<<<<<<< StructArray.ino >>>>>>>>>>>>>>>>>



#include "Commands.h"    

Commands cmd;

void setup() {

    Serial.begin ( 115200 );

    Serial.println ( "EXECUTING:" );

    cmd.execute ( 'a', '?' );

    cmd.execute ( 'b', '?' );

    cmd.execute ( 'b', 'x' );

    Serial.println ( "DONE" );

}



void loop(){}

If I refactor Commands into Template.h and Foo.h (as below), I get four compile errors that I don't understand how to fix:

Severity Code Description File Line
Error error: invalid use of template-name 'Template' without an argument list D:DocumentsArduinoStructArrayFoo.h 6
Error error: 'myCommands' was not declared in this scope D:DocumentsArduinoStructArrayFoo.h 11
Error error: 'myCommands' was not declared in this scope D:DocumentsArduinoStructArrayFoo.h 11
Error error: invalid use of template-name 'Foo' without an argument list D:DocumentsArduinoStructArrayStructArray.ino 7

Here is the code for Template.h:

#pragma once

template <class T>

class Template {

public:

    typedef void ( T::*FunctionPointer )( char, char );



    struct command {

        char sel;

        char act;

        char const *desc;

        FunctionPointer funcPtr;

    };



    void show ( char sel, char act ) {

        Serial.print ( "SEL = " );

        Serial.print ( sel );

        Serial.print ( " ACT = " );

        Serial.println ( act );

    }



    void execute ( char sel, char act, int cmdSize ) {

        for (int i = 0; i < cmdSize; i++) {

            if (T::myCommands[i].sel == sel && T::myCommands [i].act == act) {

                Serial.println ( T::myCommands [i].desc );

                ( this->*T::myCommands [i].funcPtr )( sel, act );

                return;

            }

        }

        Serial.print ( F ( "Unknown SEL/ACT Pair:" ) );

        Serial.print ( sel );

        Serial.print ( '/' );

        Serial.println ( act );

    }

};

And Foo.h:

#pragma once

#include "Template.h"

template<class T>

class Foo {

public:

    Template::command myCommands [2] = {

    command { 'a','?',"FOO-A", &Foo::foo },

    command { 'b','x',"FOO-B", &Foo::bar },

    };



    int cmdSize = sizeof ( myCommands ) / sizeof ( myCommands [0] );





    void foo ( char sel, char act ) {

        show ( { sel }, { act } );

    }



    void bar ( char sel, char act ) {

        show ( { sel }, { act } );

    }

};

If I start you out on the non-templated version, you will see that you need to make some changes.

class Commands {

public:

    typedef void ( Commands::*FunctionPointer )( char, char );



    struct command {

        char sel;

        char act;

        char const *desc;

        FunctionPointer funcPtr;

    };



    command myCommands [2] = {

            { 'a','?',"FOO", &Commands::foo },

            { 'b','x',"BAR", &Commands::bar }

    };



    int cmdSize = sizeof ( this->myCommands ) / sizeof ( this->myCommands [0] );



    void foo ( char sel, char act ) {

        char buf[2] = {sel};

        Serial.println ( buf );

    }



    void bar ( char sel, char act ) {

        char buf[2] = { sel };

        Serial.println ( buf );

    }



    void execute ( char sel, char act ) {

        for (int i = 0; i < cmdSize; i++) {

            if (myCommands [i].sel == sel && myCommands [i].act == act) {

                Serial.println ( myCommands [i].desc );

                (this->*myCommands [i].funcPtr)( sel, act );

            }

        }

    }



};

Once that is solved you can attack the templating (which I didn't see the purpose right now in this example since the foo and bar were part of the template class.)