Làm thế nào để khởi tạo các thành viên tĩnh riêng trong C ++?

Cách tốt nhất để khởi tạo một thành viên dữ liệu tĩnh, riêng tư trong C ++ là gì? Tôi đã thử điều này trong tệp tiêu đề của mình, nhưng nó mang lại cho tôi các lỗi liên kết lạ:

class foo
{
    private:
        static int i;
};

int foo::i = 0;

Tôi đoán điều này là do tôi không thể khởi tạo một thành viên tư nhân từ bên ngoài lớp học. Vì vậy, cách tốt nhất để làm điều này là gì?

Khai báo lớp phải ở trong tệp tiêu đề (Hoặc trong tệp nguồn nếu không được chia sẻ).
Tập tin: foo.h

class foo
{
    private:
        static int i;
};

Nhưng việc khởi tạo phải ở trong tệp nguồn.
Tập tin: foo.cpp

int foo::i = 0;

Nếu việc khởi tạo nằm trong tệp tiêu đề thì mỗi tệp bao gồm tệp tiêu đề sẽ có định nghĩa về thành viên tĩnh. Do đó, trong giai đoạn liên kết, bạn sẽ gặp lỗi liên kết vì mã để khởi tạo biến sẽ được xác định trong nhiều tệp nguồn. Việc khởi tạo static int iphải được thực hiện bên ngoài bất kỳ chức năng nào.

Lưu ý: Matt Curtis: điểm ra rằng C ++ cho phép đơn giản hóa những điều trên nếu biến thành viên tĩnh là kiểu int const (ví dụ int, bool, char). Sau đó, bạn có thể khai báo và khởi tạo biến thành viên trực tiếp bên trong khai báo lớp trong tệp tiêu đề:

class foo
{
    private:
        static int const i = 42;
};

Đối với một biến :

foo.h:

class foo
{
private:
    static int i;
};

foo.cpp:

int foo::i = 0;

Điều này là do chỉ có thể có một ví dụ foo::itrong chương trình của bạn. Nó tương đương với extern int itrong một tệp tiêu đề và int itrong một tệp nguồn.

Đối với một hằng số, bạn có thể đặt giá trị thẳng vào khai báo lớp:

class foo
{
private:
    static int i;
    const static int a = 42;
};

Kể từ C ++ 17, các thành viên tĩnh có thể được xác định trong tiêu đề với từ khóa nội tuyến .

http://en.cppreference.com/w/cpp/lingu/static

"Một thành viên dữ liệu tĩnh có thể được khai báo nội tuyến. Một thành viên dữ liệu tĩnh nội tuyến có thể được định nghĩa trong định nghĩa lớp và có thể chỉ định một trình khởi tạo thành viên mặc định. Nó không cần một định nghĩa ngoài lớp:"

struct X
{
    inline static int n = 1;
};

Đối với những người xem tương lai của câu hỏi này, tôi muốn chỉ ra rằng bạn nên tránh những gì khỉ0506 đang gợi ý .

Các tập tin tiêu đề là để khai báo.

Các tệp tiêu đề được biên dịch một lần cho mỗi .cpptệp trực tiếp hoặc gián tiếp #includeschúng và mã bên ngoài bất kỳ chức năng nào được chạy khi khởi tạo chương trình, trước đó main().

Bằng cách đặt: foo::i = VALUE;vào tiêu đề, foo:isẽ được gán giá trị VALUE(bất kể đó là gì) cho mỗi .cpptệp và các phép gán này sẽ xảy ra theo thứ tự không xác định (được xác định bởi trình liên kết) trước khi main()được chạy.

Điều gì xảy ra nếu chúng ta #define VALUElà một số khác nhau trong một trong các .cpptệp của chúng tôi ? Nó sẽ biên dịch tốt và chúng tôi sẽ không có cách nào để biết ai thắng cho đến khi chúng tôi chạy chương trình.

Không bao giờ đặt mã thực thi vào một tiêu đề cho cùng một lý do mà bạn không bao giờ #includelà một .cpptệp.

bao gồm các trình bảo vệ (mà tôi đồng ý bạn nên luôn luôn sử dụng) bảo vệ bạn khỏi một điều khác biệt: cùng một tiêu đề được gián tiếp #included nhiều lần trong khi biên dịch một .cpptệp duy nhất

Với trình biên dịch Microsoft [1], các biến tĩnh không intgiống như cũng có thể được xác định trong tệp tiêu đề, nhưng bên ngoài khai báo lớp, sử dụng cụ thể của Microsoft __declspec(selectany).

class A
{
    static B b;
}

__declspec(selectany) A::b;

Lưu ý rằng tôi không nói điều này là tốt, tôi chỉ nói nó có thể được thực hiện.

[1] Những ngày này, nhiều trình biên dịch hơn hỗ trợ của MSC __declspec(selectany)- ít nhất là gcc và clang. Có thể nhiều hơn nữa.

int foo::i = 0; 

Là cú pháp đúng để khởi tạo biến, nhưng nó phải đi trong tệp nguồn (.cpp) chứ không phải trong tiêu đề.

Bởi vì nó là một biến tĩnh, trình biên dịch chỉ cần tạo một bản sao của nó. Bạn phải có một dòng "int foo: i" một số nơi trong mã của bạn để báo cho trình biên dịch nơi đặt nó nếu không bạn sẽ gặp lỗi liên kết. Nếu đó là trong một tiêu đề, bạn sẽ nhận được một bản sao trong mỗi tệp bao gồm tiêu đề, do đó, nhận được nhiều lỗi biểu tượng được xác định từ trình liên kết.

Tôi không có đủ đại diện ở đây để thêm nhận xét này dưới dạng nhận xét, nhưng IMO thật tốt khi viết tiêu đề của bạn bằng #include Guard, điều này được Paranaix lưu ý vài giờ trước sẽ ngăn ngừa lỗi đa định nghĩa. Trừ khi bạn đã sử dụng một tệp CPP riêng biệt, không cần thiết chỉ sử dụng một tệp để khởi tạo các thành viên không tách rời tĩnh.

#ifndef FOO_H
#define FOO_H
#include "bar.h"

class foo
{
private:
    static bar i;
};

bar foo::i = VALUE;
#endif

Tôi thấy không cần sử dụng tệp CPP riêng cho việc này. Chắc chắn, bạn có thể, nhưng không có lý do kỹ thuật tại sao bạn nên phải.

Nếu bạn muốn khởi tạo một số loại hỗn hợp (chuỗi ký tự), bạn có thể làm một cái gì đó như thế:

class SomeClass {
  static std::list<string> _list;

  public:
    static const std::list<string>& getList() {
      struct Initializer {
         Initializer() {
           // Here you may want to put mutex
           _list.push_back("FIRST");
           _list.push_back("SECOND");
           ....
         }
      }
      static Initializer ListInitializationGuard;
      return _list;
    }
};

Vì ListInitializationGuardlà một biến tĩnh bên trong SomeClass::getList()phương thức, nó sẽ chỉ được xây dựng một lần, điều đó có nghĩa là hàm tạo được gọi một lần. Điều này sẽ initialize _listbiến thành giá trị bạn cần. Bất kỳ cuộc gọi tiếp theo nào getListsẽ chỉ trả về _listđối tượng đã khởi tạo .

Tất nhiên bạn phải truy cập _listđối tượng luôn bằng getList()phương thức gọi .

Mẫu xây dựng tĩnh C ++ 11 hoạt động cho nhiều đối tượng

Một thành ngữ đã được đề xuất tại: https://stackoverflow.com/a/27088552/895245 nhưng ở đây có phiên bản sạch hơn không yêu cầu tạo phương thức mới cho mỗi thành viên.

main.cpp

#include <cassert>
#include <vector>

// Normally on the .hpp file.
class MyClass {
public:
    static std::vector<int> v, v2;
    static struct StaticConstructor {
        StaticConstructor() {
            v.push_back(1);
            v.push_back(2);
            v2.push_back(3);
            v2.push_back(4);
        }
    } _staticConstructor;
};

// Normally on the .cpp file.
std::vector<int> MyClass::v;
std::vector<int> MyClass::v2;
// Must come after every static member.
MyClass::StaticConstructor MyClass::_staticConstructor;

int main() {
    assert(MyClass::v[0] == 1);
    assert(MyClass::v[1] == 2);
    assert(MyClass::v2[0] == 3);
    assert(MyClass::v2[1] == 4);
}

GitHub ngược dòng .

Biên dịch và chạy:

g++ -ggdb3 -O0 -std=c++11 -Wall -Wextra -pedantic -o main.out main.cpp
./main.out

Xem thêm: constructor tĩnh trong C ++? Tôi cần khởi tạo các đối tượng tĩnh riêng

Đã thử nghiệm trên Ubuntu 19.04.

Biến nội tuyến C ++ 17

Được đề cập tại: https://stackoverflow.com/a/45062055/895245 nhưng đây là một ví dụ có thể chạy được nhiều biến để làm cho nó rõ ràng hơn: Làm thế nào để các biến nội tuyến hoạt động?

Bạn cũng có thể bao gồm bài tập trong tệp tiêu đề nếu bạn sử dụng bộ bảo vệ tiêu đề. Tôi đã sử dụng kỹ thuật này cho một thư viện C ++ mà tôi đã tạo. Một cách khác để đạt được kết quả tương tự là sử dụng các phương thức tĩnh. Ví dụ...

class Foo
   {
   public:
     int GetMyStatic() const
     {
       return *MyStatic();
     }

   private:
     static int* MyStatic()
     {
       static int mStatic = 0;
       return &mStatic;
     }
   }

Đoạn mã trên có "phần thưởng" không yêu cầu tệp CPP / nguồn. Một lần nữa, một phương thức tôi sử dụng cho các thư viện C ++ của mình.

Tôi làm theo ý tưởng từ Karl. Tôi thích nó và bây giờ tôi cũng sử dụng nó. Tôi đã thay đổi một chút ký hiệu và thêm một số chức năng

#include <stdio.h>

class Foo
{
   public:

     int   GetMyStaticValue () const {  return MyStatic();  }
     int & GetMyStaticVar ()         {  return MyStatic();  }
     static bool isMyStatic (int & num) {  return & num == & MyStatic(); }

   private:

      static int & MyStatic ()
      {
         static int mStatic = 7;
         return mStatic;
      }
};

int main (int, char **)
{
   Foo obj;

   printf ("mystatic value %d\n", obj.GetMyStaticValue());
   obj.GetMyStaticVar () = 3;
   printf ("mystatic value %d\n", obj.GetMyStaticValue());

   int valMyS = obj.GetMyStaticVar ();
   int & iPtr1 = obj.GetMyStaticVar ();
   int & iPtr2 = valMyS;

   printf ("is my static %d %d\n", Foo::isMyStatic(iPtr1), Foo::isMyStatic(iPtr2));
}

đầu ra này

mystatic value 7
mystatic value 3
is my static 1 0

Cũng làm việc trong tập tin privateStatic.cpp:

#include <iostream>

using namespace std;

class A
{
private:
  static int v;
};

int A::v = 10; // possible initializing

int main()
{
A a;
//cout << A::v << endl; // no access because of private scope
return 0;
}

// g++ privateStatic.cpp -o privateStatic && ./privateStatic

Một set_default()phương pháp thì sao?

class foo
{
    public:
        static void set_default(int);
    private:
        static int i;
};

void foo::set_default(int x) {
    i = x;
}

Chúng ta sẽ chỉ phải sử dụng set_default(int x)phương thức và staticbiến của chúng ta sẽ được khởi tạo.

Điều này sẽ không bất đồng với các ý kiến ​​còn lại, thực ra nó tuân theo cùng một nguyên tắc khởi tạo biến trong phạm vi toàn cầu, nhưng bằng cách sử dụng phương pháp này, chúng tôi làm cho nó rõ ràng (và dễ hiểu) thay vì có định nghĩa của biến treo ở đó.

Vấn đề liên kết bạn gặp phải có thể là do:

• Cung cấp cả định nghĩa thành viên lớp và tĩnh trong tệp tiêu đề,
• Bao gồm tiêu đề này trong hai hoặc nhiều tệp nguồn.

Đây là một vấn đề phổ biến cho những người bắt đầu với C ++. Thành viên lớp tĩnh phải được khởi tạo trong một đơn vị dịch nghĩa là trong tệp nguồn đơn.

Thật không may, thành viên lớp tĩnh phải được khởi tạo bên ngoài thân lớp. Điều này làm phức tạp việc viết mã chỉ tiêu đề, và do đó, tôi đang sử dụng cách tiếp cận khá khác nhau. Bạn có thể cung cấp đối tượng tĩnh của mình thông qua hàm lớp tĩnh hoặc không tĩnh, ví dụ:

class Foo
{
    // int& getObjectInstance() const {
    static int& getObjectInstance() {
        static int object;
        return object;
    }

    void func() {
        int &object = getValueInstance();
        object += 5;
    }
};

Một cách "trường học cũ" để xác định các hằng số là thay thế chúng bằng enum:

class foo
{
    private:
        enum {i = 0}; // default type = int
        enum: int64_t {HUGE = 1000000000000}; // may specify another type
};

Cách này không yêu cầu cung cấp định nghĩa và tránh tạo ra giá trị không đổi , điều này có thể giúp bạn đỡ đau đầu, ví dụ như khi bạn vô tình sử dụng ODR .

Tôi chỉ muốn đề cập đến một cái gì đó hơi lạ với tôi khi lần đầu tiên tôi gặp phải điều này.

Tôi cần khởi tạo một thành viên dữ liệu tĩnh riêng trong một lớp mẫu.

trong .h hoặc .hpp, có vẻ như thế này để khởi tạo một thành viên dữ liệu tĩnh của một lớp mẫu:

template<typename T>
Type ClassName<T>::dataMemberName = initialValue;

Điều này phục vụ mục đích của bạn?

//header file

struct MyStruct {
public:
    const std::unordered_map<std::string, uint32_t> str_to_int{
        { "a", 1 },
        { "b", 2 },
        ...
        { "z", 26 }
    };
    const std::unordered_map<int , std::string> int_to_str{
        { 1, "a" },
        { 2, "b" },
        ...
        { 26, "z" }
    };
    std::string some_string = "justanotherstring";  
    uint32_t some_int = 42;

    static MyStruct & Singleton() {
        static MyStruct instance;
        return instance;
    }
private:
    MyStruct() {};
};

//Usage in cpp file
int main(){
    std::cout<<MyStruct::Singleton().some_string<<std::endl;
    std::cout<<MyStruct::Singleton().some_int<<std::endl;
    return 0;
}