Как Вы создаете статический класс в C++?

В C++ Вы хотите создать статическую функцию класса (не статический класс).

class BitParser {
public:
  ...
  static ... getBitAt(...) {
  }
};

необходимо тогда быть в состоянии назвать использование функции BitParser:: getBitAt (), не инстанцируя объекта, который я предполагаю, является желаемым результатом.

, Если Вы ищете способ применить "статическое" ключевое слово к классу, как Вы, может в C#, например

, статические классы являются просто содержанием руки компилятора Вы и мешать Вам писать любые методы/переменные экземпляра.

, Если Вы просто пишете нормальный класс без каких-либо методов/переменных экземпляра, это - то же самое, и это - то, что Вы сделали бы в C++

Можно также создать бесплатную функцию в пространстве имен:

В BitParser.h

namespace BitParser
{
    bool getBitAt(int buffer, int bitIndex);
}

В BitParser.cpp

namespace BitParser
{
    bool getBitAt(int buffer, int bitIndex)
    {
        //get the bit :)
    }
}

В целом это было бы предпочтительным способом записать код. Когда нет никакой потребности в объекте, не используют класс.

Рассмотрите решение .

1. Matt Price В C++, "статический класс" не имеет никакого значения. Самой близкой вещью является класс только со статическими методами и участниками.
2. Используя статические методы только ограничит Вас.

то, Что Вы хотите, выражено в семантике C++, для помещения функции (для него функция) в пространстве имен.

Редактирование 11.11.2011

нет никакого "статического класса" в C++. Самое близкое понятие было бы классом только со статическими методами. Например:

// header
class MyClass
{
   public :
      static void myMethod() ;
} ;

// source
void MyClass::myMethod()
{
   // etc.
}

, Но необходимо помнить, что "статические классы" являются взломами в подобном Java виде языков (например, C#), которые неспособны иметь функции лица, не являющегося членом какой-либо организации, таким образом, они должны вместо этого переместить их в классах как статические методы.

В C++, что Вы действительно хотите, функция лица, не являющегося членом какой-либо организации, которую Вы объявите в пространстве имен:

// header
namespace MyNamespace
{
   void myMethod() ;
}

// source
namespace MyNamespace
{
   void myMethod()
   {
      // etc.
   }
}

, Почему это?

В C++, пространство имен более мощно, чем классы для "шаблона" статического метода Java, потому что:

• статические методы имеют доступ к классам частные символы
• , частные статические методы все еще видимы (если недоступный) всем, которые нарушают несколько инкапсуляцию
• , статические методы не могут быть вперед - объявил
• , статические методы не могут быть перегружены пользователем класса, не изменяя заголовок библиотеки
• нет ничего, что может быть сделано статическим методом, который не может быть добит большего успеха, чем (возможно друг), функция лица, не являющегося членом какой-либо организации, в тех же пространствах имен пространства имен
• имеет их собственную семантику (они могут быть объединены, они могут быть анонимными, и т.д.)
• и т.д.

Заключение: не Делайте скопировать/вставить что шаблон Java/C# в C++. В Java/C# шаблон обязателен. Но в C++, это - плохой стиль.

Редактирование 10.06.2010

было аргументом в фаворе статическому методу, потому что иногда, нужно использовать статическую переменную члена парламента, не занимающего официального поста.

я не соглашаюсь несколько как шоу ниже:

"Статического члена парламента, не занимающего официального поста" решение

// HPP

class Foo
{
   public :
      void barA() ;
   private :
      void barB() ;
      static std::string myGlobal ;
} ;

Сначала, myGlobal называют myGlobal, потому что это - все еще глобальная частная переменная. Взгляд на источник CPP разъяснит что:

// CPP
std::string Foo::myGlobal ; // You MUST declare it in a CPP

void Foo::barA()
{
   // I can access Foo::myGlobal
}

void Foo::barB()
{
   // I can access Foo::myGlobal, too
}

void barC()
{
   // I CAN'T access Foo::myGlobal !!!
}

На первый взгляд, факт бесплатная функция barC не может получить доступ к Foo:: myGlobal кажется хорошей вещью с точки зрения инкапсуляции... Это прохладно, потому что кто-то смотрящий на HPP не будет в состоянии (если, обращаясь к саботажу) для доступа к Foo:: myGlobal.

, Но если Вы смотрите на него тесно, Вы найдете, что это - колоссальная ошибка: Не только Ваша частная переменная должна все еще быть объявлена в HPP (и так, видимая ко всему миру, несмотря на то, чтобы быть частным), но необходимо объявить в том же HPP все (как ВСЕГО) функции, которые будут разрешены получить доступ к нему!!!

Так использование частного статического участника похоже на обход, снаружи в обнаженном виде со списком Ваших возлюбленных, татуированных на Вашей коже: Никто не разрешен затронуть, но все в состоянии посмотреть на. И премия: у Всех могут быть названия разрешенных играть с Вашими участниками.

private действительно...:-D

"Анонимные пространства имен" решение

Анонимные пространства имен будут иметь преимущество создания вещей, частных действительно частный.

Первый, заголовок HPP

// HPP

namespace Foo
{
   void barA() ;
}

Только, чтобы быть уверенными Вы отметили: нет никакого бесполезного объявления зубца, ни myGlobal. Что означает, что никакое чтение заголовка не знает то, что скрыто позади barA.

Затем CPP:

// CPP
namespace Foo
{
   namespace
   {
      std::string myGlobal ;

      void Foo::barB()
      {
         // I can access Foo::myGlobal
      }
   }

   void barA()
   {
      // I can access myGlobal, too
   }
}

void barC()
{
   // I STILL CAN'T access myGlobal !!!
}

, Как Вы видите, как так называемый "статический класс" объявление, fooA и fooB все еще в состоянии получить доступ к myGlobal. Но никто больше не может. И никто больше за пределами этой CPP не знает fooB, и myGlobal даже существуют!

В отличие от "статического класса", идущего на обнаженной фигуре с ее адресной книгой, татуированной на ее коже, "анонимное" пространство имен полностью одето , который кажется вполне лучше инкапсулировавшим AFAIK.

это действительно имеет значение?

, Если пользователи Вашего кода не являются саботажниками (я позволю Вам как осуществление, находят, как можно получить доступ к половому органу общедоступного класса с помощью грязного неопределенного поведением взлома...), что private, private, даже если это видимо в private раздел класса, объявленного в заголовке.

однако, если необходимо добавить другую "закрытую функцию" с доступом к члену парламента, не занимающему официального поста, все еще необходимо объявить его ко всему миру путем изменения заголовка, который является парадоксом, что касается меня: , Если я изменяю реализацию своего кода (часть CPP), тогда интерфейс (часть HPP) не должен изменяться. Заключение в кавычки Leonidas: " Это - ИНКАПСУЛЯЦИЯ! "

Редактирование 20.09.2014

, Когда статические методы классов, на самом деле лучше, чем пространства имен с функциями лица, не являющегося членом какой-либо организации?

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

namespace alpha
{
   void foo() ;
   void bar() ;
}

struct Beta
{
   static void foo() ;
   static void bar() ;
};

template <typename T>
struct Gamma
{
   void foobar()
   {
      T::foo() ;
      T::bar() ;
   }
};

Gamma<alpha> ga ; // compilation error
Gamma<Beta> gb ;  // ok
gb.foobar() ;     // ok !!!

, поскольку, если класс может быть шаблонным параметром, пространства имен не могут.

Вы «можете» иметь статический класс в C ++, как упоминалось ранее, статический класс - это тот, который не имеет никаких объектов, созданных для него. В C ++ это можно получить, объявив конструктор / деструктор закрытым. Конечный результат тот же.

Это похоже на способ C # выполнения этого в C ++

В C # file.cs вы можете иметь частную переменную внутри общедоступной функции. В другом файле вы можете использовать ее, вызвав пространство имен с функцией, как в:

MyNamespace.Function(blah);

Здесь как сделать то же самое в C ++:

SharedModule.h

class TheDataToBeHidden
{
  public:
    static int _var1;
    static int _var2;
};

namespace SharedData
{
  void SetError(const char *Message, const char *Title);
  void DisplayError(void);
}

SharedModule.cpp

//Init the data (Link error if not done)
int TheDataToBeHidden::_var1 = 0;
int TheDataToBeHidden::_var2 = 0;


//Implement the namespace
namespace SharedData
{
  void SetError(const char *Message, const char *Title)
  {
    //blah using TheDataToBeHidden::_var1, etc
  }

  void DisplayError(void)
  {
    //blah
  }
}

OtherFile.h

#include "SharedModule.h"

OtherFile.cpp

//Call the functions using the hidden variables
SharedData::SetError("Hello", "World");
SharedData::DisplayError();

В управляемом C ++ синтаксис статического класса: -

public ref class BitParser abstract sealed
{
    public:
        static bool GetBitAt(...)
        {
            ...
        }
}

... лучше поздно, чем никогда ...