声明全局变量，在方法内初始化

Question

I am creating a thrift client, which has a bunch of overhead: a TSocket , a TBufferedTransport , and a TBinaryProtocol . Usually it is created like this

Example Thrift Client

int main(int argc, char **argv) {
    shared_ptr<TTransport> mysocket(new TSocket("localhost", 9090));
    shared_ptr<TTransport> mytransport(new TBufferedTransport(mysocket));
    shared_ptr<TProtocol> myprotocol(new TBinaryProtocol(mytransport));
    TestServiceClient client(myprotocol);

    try {
        mytransport->open();
        client.testmethod();  //and you can call server methods like so
        mytransport->close();
    }catch (TException &tx) {
        printf("ERROR: %s\n", tx.what());
    }
}

However, for my client, I want it in the form of a static library. Thus, there is no main method, and I created init() and exit() methods to open and close mytransport . That also meant I had to make mysocket , mytransport , myprotocol , and client all global variables, but I also want to set mysocket to an ip other than "localhost", which means initializing mysocket inside a method. Any ideas?

PS. Also, does anybody know how I can call init() and exit() automatically when the static library is opened and closed? [SOLVED]

edit: I forgot to mention that I can't initialize mysocket until I know the correct ip, so I don't think I can declare mysocket as a global variable anyways

Answer 1

After reading the question more thoroughly, I think this may be more along the lines of what you are looking for:

mylib.h

class libClosure{
  public:
  libClosure();
  ~libClosure();
};

mylib.cpp

#include "mylib.h"
#include <iostream>

using namespace std;

libClosure::libClosure(){ cout << "call open()" << endl;}
libClosure::~libClosure(){ cout << "call close()" << endl;}

libClosure __lc;

main.cpp

#include "mylib.h"
#include <iostream>

using namespace std;

int main(){
  cout << "client.testmethod()" << endl;
  return 0;
}

output

call open()
client.testmethod()
call close()

Constructing an initializing object within an implementation file is a common way to achieve exactly what you're looking for. Essentially, the constructor for class libClosure becomes your entry point, and the destructor for class libClosure becomes your exit point.

The reason this works is because all implementation files for the headers must construct their global variables before main() is run. You can't guarantee that one implementation file will be constructed/destructed before another, but you know that all objects in implementation files must be constructed before the main() at some point, and destructed after the main() at some point.

Answer 2

I ended up solving it myself. Even though using static local variables like Aggieboy suggested seems perfectly valid, I think this is a little simpler:

barebones version

shared_ptr<TTransport> mysocket(createTSocket());

TSocket* createTSocket() {
    //init stuff goes here, for example
    string ip = "localhost"
    int port = 9090

    return new TSocket(ip,port)
}

the full code (well, most of it)

class ThriftProxy {
public:
    ThriftProxy() :
        trans(createTSocket()),
        proto(new TBinaryProtocol(trans)),
        client(proto)
    {
        trans->open();
    }

    TSocket* createTSocket() {
        //default: ip = "localhost", port = 9090
        string ip = "localhost";
        int port = 9090;

                    //get ip and port from a text file

        return new TSocket(ip, port);
    }

    ~ThriftProxy()
    {
        trans->close();
    }

private:
    boost::shared_ptr<TSocket> trans;
    boost::shared_ptr<TProtocol> proto;
public:
    XtkServiceClient client;
};