如何将静态向量添加到类

Question

I have a class and i want a vector to live for the the life of the programe so i am using a static vector.

Please look at my code and advise me if their is better way of using static variable.

static std::vector<std::string> Stack;


class Test
{


public:
void AddStack(std::string str)
void PopStack()

};


void Test::AddStack(std::string str)
{

Stack.insert(Stack.end(),str.begin(),str.end());

}


void Test::PopStack()
{

   if(!Stack.empty() )
    {
      Stack.pop_back();

    } 

}

Answer 1

Option 1

Since Stack is used solely in the implementation of the member functions of Test , make that a private and static member variable of the class.

class Test
{
   public:
      void AddStack(std::string str);
      void PopStack();

   private:
         static std::vector<std::string> Stack;
};

and in a .cpp file, add:

std::vector<std::string> Test::Stack;

Option 2

Make Stack available to the member functions of Test through a function call instead of a variable.

class Test
{
   public:
      void AddStack(std::string str);
      void PopStack();

   private:
      static std::vector<std::string>& getStack();
};

Implementation:

std::vector<std::string>& getStack()
{
   static std::vector<std::string> Stack;
   return Stack;
}

void Test::AddStack(std::string str)
{
   auto& Stack = getStack();
   Stack.insert(Stack.end(),str.begin(),str.end());
}

void Test::PopStack()
{
   auto& Stack = getStack();
   if(!Stack.empty() )
   {
      Stack.pop_back();
   } 
}

Option 3

Make Test a singleton and make Stack a non- static member of the class.

class Test
{
   public:

      static Test& instance();
      void AddStack(std::string str);
      void PopStack();

   private:
      std::vector<std::string> Stack;
};

Implementation:

Test& Test::instance()
{
   static Test theInstance;
   return theInstance;
}

void Test::AddStack(std::string str)
{
   Stack.insert(Stack.end(),str.begin(),str.end());
}

void Test::PopStack()
{
   if(!Stack.empty() )
   {
      Stack.pop_back();
   } 
}

and use it as:

Test::instance().AddStack("abcd");
Test::instance().PopStack();

Answer 2

you must be careful with static variables, I suggest to consider this first:

1. Dynamic memory allocation. vectors have bad habit to realloc memory when need more space, and I'm not sure about the impact of dynamic memory allocation with static variables, because static variables are created in heap and you don't want fragmented memory there. The implementation will depends of the compiler, and probably, some fancy option for it.

2. Classes functions related with that variable must be static too, because by definition static variables exist always, and function related must exist always too (easy way to explain). In Other words, static functions only have access to static variables for modifications, and that means a bunch of static functions.

I suggest a nice and easy "export" variable, as I see, does the job without problems/restrictions of static variables.

blabla.h

export std::vector<std::string> my_no_static_vector;

blabla.cpp

#include "blabla.h"
std::vector<std::string> my_no_static_vector;