How do I avoid the global here ?

[manasij7479]

namespace mm
{

    static std::vector<std::string> result;
    
    static int get_table_names_cb(void *NotUsed, int argc, char **argv, char **col)
    {
        for(int i=0; i<argc; ++i)
            result.push_back((argv[i] ? argv[i] : "NULL"));
        return 0;
    }
    
    std::vector<std::string> getTableNames(Database& db)
    {
        std::string command="select name from sqlite_master where type = \"table\";";
        db(command,get_table_names_cb);
        std::vector<std::string> ret;
        std::swap(ret,result);
        return ret;
    }

}

Even if I used lambda captures (which I can not because the API must take function pointers), the problem would still remain.

Is there a good alternative when dealing with callbacks like this?

[MutantJohn]

Wait, why doesn't passing as a reference work here?

[cyberfish]

Many APIs that take callbacks would allow you to pass in a "private user data" void pointer that will get passed along to your callback function. It's kind of like a way to emulate lambda capture, but has existed long before C++11.

If it doesn't, I don't think there's much you can do.

[manasij7479]

Thanks, that void* was that private argument.

    static int get_table_names_cb(void *vec, int argc, char **argv, char **col)
    {
        auto result =static_cast<std::vector<std::string>*>(vec);
        for(int i=0; i<argc; ++i)
            result->push_back((argv[i] ? argv[i] : "NULL"));
        return 0;
    }
    
    std::vector<std::string> getTableNames(Database& db)
    {
        std::string command="select name from sqlite_master where type = \"table\";";
        std::vector<std::string> ret;
        db(command,get_table_names_cb,&ret);
        return ret;
    }

Looks un-C++ish...but works.

[Elkvis]

technically that's not global. that's namespace-local. having variables in a namespace like that is generally considered acceptable, because they're grouped in a place where things can't automatically see them polluting the global namespace.

[laserlight]

technically that's not global. that's namespace-local. having variables in a namespace like that is generally considered acceptable, because they're grouped in a place where things can't automatically see them polluting the global namespace.

The issue with global variables is more than just the risk of name collision. It includes the problems associated with global state, and this does not change with the introduction of a namespace.

[phantomotap]

Looks un-C++ish...but works.

O_o

I make such cases more "C++ish" by wrapping the API layer with a version of `Boost::Any'; the difference isn't very big, but you can do a lot of "firewall" stuff with a tool like `Boost::Any' so that you don't have to repeat yourself.

Soma

[King Mir]

Looks un-C++ish...but works.

That's because callback function pointers are a C idiom. In C++ an API can use templates to be more typesafe and fast, though often with a penalty in code size.