Статична константа рядка (член класу)

Я хотів би мати приватну статичну константу для класу (в даному випадку фабрика форм).

Я хотів би мати щось подібне.

class A {
   private:
      static const string RECTANGLE = "rectangle";
}

На жаль, я отримую всілякі помилки від компілятора C ++ (g ++), наприклад:

ISO C ++ забороняє ініціалізувати член "RECTANGLE"

недійсна ініціалізація в класі статичного члена даних неінтегрального типу 'std :: string'

помилка: робить "RECTANGLE" статичним

Це говорить мені про те, що такий тип дизайну членів не відповідає стандарту. Як у вас є приватна буквальна константа (або, можливо, загальнодоступна) без використання директиви #define (я хочу уникнути потворності глобальності даних!)

Будь-яка допомога вдячна.

Ви повинні визначити свого статичного члена поза визначенням класу та надати там ініціалізатор.

Спочатку

// In a header file (if it is in a header file in your case)
class A {   
private:      
  static const string RECTANGLE;
};

і потім

// In one of the implementation files
const string A::RECTANGLE = "rectangle";

Синтаксис, який ви спочатку намагалися використати (ініціалізатор всередині класу визначення), дозволений лише з інтегральними та переліковими типами.

Починаючи з C ++ 17, у вас є ще одна опція, яка досить схожа на вашу первісну декларацію: вбудовані змінні

// In a header file (if it is in a header file in your case)
class A {   
private:      
  inline static const string RECTANGLE = "rectangle";
};

Не потрібно додаткового визначення.

Або замість цього constви можете заявити про це constexprу цьому варіанті. Явне inlineбільше не буде необхідним, оскільки це constexprозначає inline.

На мові C ++ 11 ви можете зараз:

class A {
 private:
  static constexpr const char* STRING = "some useful string constant";
};

Всередині визначень класів ви можете оголошувати лише статичні члени. Їх треба визначити поза класом. Для інтегральних констант часу компіляції стандарт робить виняток, що ви можете "ініціалізувати" членів. Це все ще не визначення. Наприклад, адреса не буде працювати без визначення, наприклад.

Хочу зазначити, що я не бачу переваги використання std :: string над const char [] для констант . std :: string є приємним і всім, але він вимагає динамічної ініціалізації. Отже, якщо ви пишете щось подібне

const std::string foo = "hello";

в області простору імен конструктор foo буде запущений безпосередньо перед виконанням основних запусків, і цей конструктор створить копію постійного "привіт" у пам'яті купи. Якщо ви дійсно не потребуєте RECTANGLE, щоб бути std :: string, ви можете так само добре писати

// class definition with incomplete static member could be in a header file
class A {
    static const char RECTANGLE[];
};

// this needs to be placed in a single translation unit only
const char A::RECTANGLE[] = "rectangle";

Там! Ні розподілу купи, ні копіювання, ні динамічної ініціалізації.

Ура, с.

Це лише додаткова інформація, але якщо ви дійсно хочете рядок у файлі заголовка, спробуйте щось на кшталт:

class foo
{
public:
    static const std::string& RECTANGLE(void)
    {
        static const std::string str = "rectangle";

        return str;
    }
};

Хоча я сумніваюся, що це рекомендується.

У C ++ 17 ви можете використовувати вбудовані змінні :

class A {
 private:
  static inline const std::string my_string = "some useful string constant";
};

Зауважте, що це відрізняється від відповіді безодні.7 : Цей визначає фактичний std::stringоб'єкт, а не aconst char*

Щоб використовувати цей синтаксис ініціалізації в класі, константа повинна бути статичним констатом інтегрального чи перелічувального типу, ініціалізованим постійним виразом.

Це обмеження. Отже, у цьому випадку вам потрібно визначити змінну поза класом. посилайтесь на answwer від @AndreyT

Статичні змінні класу можуть бути оголошені у заголовку, але повинні бути визначені у файлі .cpp. Це тому, що може бути лише один екземпляр статичної змінної, і компілятор не може вирішити, в який згенерований об’єктний файл його поставити, тож вам доведеться приймати рішення.

Для збереження визначення статичного значення з оголошенням у C ++ 11 може бути використана вкладена статична структура. У цьому випадку статичний член є структурою і повинен бути визначений у файлі .cpp, але значення знаходяться в заголовку.

class A
{
private:
  static struct _Shapes {
     const std::string RECTANGLE {"rectangle"};
     const std::string CIRCLE {"circle"};
  } shape;
};

Замість ініціалізації окремих членів вся статична структура ініціалізується у .cpp:

A::_Shapes A::shape;

Доступ до значень здійснюється за допомогою

A::shape.RECTANGLE;

або - оскільки члени приватні і мають на увазі використовуватись лише від A - с

shape.RECTANGLE;

Зауважимо, що це рішення все ще страждає від проблеми порядку ініціалізації статичних змінних. Коли статичне значення використовується для ініціалізації іншої статичної змінної, перша може ще не ініціалізуватися.

// file.h
class File {
public:
  static struct _Extensions {
    const std::string h{ ".h" };
    const std::string hpp{ ".hpp" };
    const std::string c{ ".c" };
    const std::string cpp{ ".cpp" };
  } extension;
};

// file.cpp
File::_Extensions File::extension;

// module.cpp
static std::set<std::string> headers{ File::extension.h, File::extension.hpp };

У цьому випадку статичні змінні заголовки будуть містити або {""}, або {".h", ".hpp"}, залежно від порядку ініціалізації, створеного лінкером.

Як зазначає @ abyss.7, ви також можете використовувати, constexprякщо значення змінної можна обчислити під час компіляції. Але якщо ви оголосите свої рядки static constexpr const char*і ваша програма використовує в std::stringіншому випадку, буде накладні витрати, оскільки новий std::stringоб’єкт буде створюватися кожен раз, коли ви використовуєте таку константу:

class A {
public:
   static constexpr const char* STRING = "some value";
};
void foo(const std::string& bar);
int main() {
   foo(A::STRING); // a new std::string is constructed and destroyed.
}

Поточний стандарт допускає таку ініціалізацію лише для статичних постійних інтегральних типів. Тож вам потрібно зробити так, як пояснив АндрейТ. Однак це буде доступно в наступному стандарті через синтаксис ініціалізації нового члена .

можна просто зробити:

static const std::string RECTANGLE() const {
    return "rectangle";
} 

або

#define RECTANGLE "rectangle"

Ви можете або піти на const char*рішення, згадане вище, але тоді, якщо вам весь час потрібна струна, у вас буде багато накладних витрат.
З іншого боку, статична рядок потребує динамічної ініціалізації, тому, якщо ви хочете використовувати її значення під час ініціалізації іншої глобальної / статичної змінної, ви можете потрапити на проблему порядку ініціалізації. Щоб цього уникнути, найдешевша річ - це доступ до об’єкта статичного рядка через геттер, який перевіряє, чи ініціалізується ваш об'єкт чи ні.

//in a header  
class A{  
  static string s;   
public:   
  static string getS();  
};  
//in implementation  
string A::s;  
namespace{  
  bool init_A_s(){  
    A::s = string("foo");   
    return true;  
  }  
  bool A_s_initialized = init_A_s();  
}  
string A::getS(){      
  if (!A_s_initialized)  
    A_s_initialized = init_A_s();  
  return s;  
}  

Не забудьте використовувати лише A::getS(). Оскільки будь-яка різьба може починатися лише шляхом main()і A_s_initializedініціалізуватися раніше main(), вам не потрібні блокування навіть у багатопотоковому середовищі. A_s_initializedза замовчуванням дорівнює 0 (перед динамічною ініціалізацією), тому якщо ви використовуєтеgetS() до ініціалізації s, ви безпечно викликаєте функцію init.

Btw, у відповіді вище: " статичний const std :: string RECTANGLE () const ", статичних функцій не може бути, constоскільки вони не можуть змінити стан, якщо будь-який об'єкт все одно (немає цього вказівника).

Швидкий перехід до 2018 року та C ++ 17.

• не використовуйте std :: string, використовуйте std :: string_view літерали
• будь ласка, зверніть увагу на "constexpr" нижче. Це також механізм "часу компіляції".
• ніякий вбудований не означає повторення
• жодні файли cpp для цього не потрібні

• static_assert 'працює' лише під час компіляції

  using namespace std::literals;
  
  namespace STANDARD {
  constexpr 
  inline 
  auto 
  compiletime_static_string_view_constant() {
  // make and return string view literal
  // will stay the same for the whole application lifetime
  // will exhibit standard and expected interface
  // will be usable at both
  // runtime and compile time
  // by value semantics implemented for you
      auto when_needed_ =  "compile time"sv;
      return when_needed_  ;
  }

  };

Вище є належним та законним стандартом громадянина C ++. Він може легко долучитися до будь-яких і всіх std :: алгоритмів, контейнерів, утиліт та іншого. Наприклад:

// test the resilience
auto return_by_val = []() {
    auto return_by_val = []() {
        auto return_by_val = []() {
            auto return_by_val = []() {
return STANDARD::compiletime_static_string_view_constant();
            };
            return return_by_val();
        };
        return return_by_val();
    };
    return return_by_val();
};

// actually a run time 
_ASSERTE(return_by_val() == "compile time");

// compile time 
static_assert(
   STANDARD::compiletime_static_string_view_constant() 
   == "compile time" 
 );

Насолоджуйтесь стандартними C ++