无论如何，从内部作用域的内部作用域初始化对象？

Question

For example:

int main()
{
    {
        // I want this array to be part of the inner scope
        string s[] = {"Ben","Joe","Bob","Matt"};

        // And I want to use it to initialize this vector, but I want this
        // vector to be visible in the outer scope
        vector<string> names(s,s+4);
    }
}

Is there any way to do that?

Answer 1

If you want the vector to be visible in the outer scope, you must declare it in the outer scope. Which means that you also have to initialize it there. The only way to declare it without initializing is by using a pointer:

int main()
{
  vector<string> * names = 0;

  {
    string s[] = {"Ben", "Joe", "Bob", "Matt"};
    names = new vector<string>(s, s+4);
  }

  // ...
  delete names;
}

Answer 2

int main()
{
    vector<string> names;
    {       
        string s[] = {"Ben","Joe","Bob","Matt"};
        names.assign(s,s+4);
    }
}

Answer 3

ldx's mentioning of pointers gave me an idea. I've never used shared_ptr before, but I thought it might be the solution, so I looked them up, and I came up with this solution:

Edit: changed to auto_ptr

int main()
{
    auto_ptr<vector<string> > vsptr;

    {
        string s[] = {"Ben", "Joe", "Bob", "Matt"};
        int cnt = sizeof(s)/sizeof(string);

        vsptr = auto_ptr<vector<string> >(new vector<string>(s,s+cnt));
    }

    vector<string> &names = *vsptr;
}

I tested it with a class that announces it's constructors, assignments and destructors, and there's only one default construction and one destruction. Of course, this requires boost if your compiler doesn't implement tr1 yet, but what compiler worth a damn doesn't?

Answer 4

Although not strictly initialising the vector, if you want your object to be auto rather than dynamically allocated you can swap it with a temporary:

{
    vector<string> names;

    {
        string s[] = {"Ben","Joe","Bob","Matt"};

        vector<string> init (s,s+4)

        swap ( names, init );
    }
}

Though you still get the major copies going on ( the char* literals copied to construct the std::strings in the array, then the std::strings in the array copied to the vector ) the swap avoids the copy of the strings from init to names.

Answer 5

There is no way to do exactly what you asked for. There are several possibilities, as other people have pointed out:

1. Declare the vector before the inner scope, and populate it during. This has the downside that the vector is hanging around empty for a bit, which is not good style, and there may be a teeny, teeny overhead by initialising it later rather than the constructor, but neither of these should matter much, since the vector has to be constructed at some point either way.

   // insert code sample here, cribbed from other answer (?)

2. Declare a scoped_ptr (or const auto_ptr, or normal pointer) before the inner scope, and a vector in the inner scope, initialising it using the constructor, and assign it to the pointer. This has almost no downside. You have to get used to using -> rather than . but most C++ programs have to do that everywhere anyway. There's a small risk you will accidentally use the unallocated pointer before the inner scope, but it should immediately produce an exception, so you should notice.

   // insert code sample here, cribbed from other answer (?)

3. Wrap up either the whole inner scope, or just the string array, in a function. This looks like complexity, but honestly, I have very very rarely regretted having the constant initialization in a clearly named function. The function can either return the array, or return a vector directly (depending whether you really need that data in the inner scope, or just want to avoid it contaminating the outer scope). Depending which way you go, it might look something like:

   vector MyFriends() { const string s[] = {"Ben","Joe","Bob","Matt"}; return vector(s, s + (sizeof(s)/sizeof(s[0])) ); // TODO: improve the calc // Note use of return value optimisation // Probably doesn't matter, but if you care, compilers may omit one or both // of the implied temporary vector objects. }

   int main() { { // Do stuff // If MyFriends depends on stuff, possibly move stuff into that func if possible // If stuff just needs access to MyFriends return value, call it again here } vector vec(MYFriends());

   // More stuff }

4. If you only want to initialise the vector as in example 3, I think C++0x supports a specific syntax to do this (??)

   // Provide example

Answer 6

Since I asked this question, I found a much better way to do this using lambdas:

int main()
{
    std::vector<std::string> v = []() -> std::vector<std::string> {
        std::string s[] = {"Ben","Joe","Bob","Matt"};
        int cnt = sizeof(s)/sizeof(s[0]);
        return std::vector<string>(s,s+cnt);
    }();
}