C ++中类似Python的静态数据存储？

Question

When I have test data objects, or other static data objects such as SQL strings, I like to keep them out of application code. In Python, this is done with a separate source file and an import as shown below. How is static data organized and used C++?

 (file: testdata.py)
x = Foo() (an object)
x.name = "Bar"
x.number = 123
..

(file: test.py)
import testdata.py
testObject1 = testdata.x 
..

Answer 1

The most flexible choice for connection strings etc. would be to create a settings file (with a format of your own choosing) and a class that can read the file, since this allows you to change the settings without recompiling the program.

For static data that you want to include in the code, you can use static class members:

// file.h
class Foo {
public:
    static string getBar();
private:
    static string bar;
};

// file.cpp
Foo::bar = "qwe";

static Foo::getBar() {
    return bar;
}

Answer 2

There are lots of possibilities. This also depends on what you're trying to do (eg do you want the values to be editable after compiling or only before compiling?

As for the later, you could use a separate translation unit.

In some header file:

extern const char *name;
extern const int number;

In one separate source file:

const char *name = "Bar";
const int number = 123;

However, you could do the class/struct approach, too:

Header file:

struct Foo {
    const char *name;
    int number;
};

extern const Foo Bar;

Source file:

const Foo Bar = {"Bar", 123};

Answer 3

You can put them in another file as well; extern data declarations in an header file, and the definitions in a .cpp file, like this:

// Foo.h

extern Foo afoo;
extern int anint;

// Foo.cpp

Foo afoo;
int anint = 0;

Then you can #include "Foo.h" wherever you want to use afoo and anint .

Answer 4

There are many ways to store data out of the source code.

For example, configuration files are stored in XML for example, though (fortunately) JSON has been gaining some grounds (not as much as I'd like to), and there are also custom formats.

Another example, for translation you might use gettext and store strings in .po files, and add new languages without recompiling.

It all works the same way, in the end:

• you define a format for the file
• you create a reader (and perhaps writer) procedure that converts between the file format and the in-memory format
• you find a way to pass the file path to the program: fixed name in current directory, fixed name in home directory, command line argument, environment variable, etc...

If you wish to do it as you did in Python, you could also compile the resources into their own DLL and pull them at runtime while loading the symbols, changing the resources would only require re-compiling this one DLL.