How do you create a static class in C

Question

How do you create a static class in C    I should be able to do something like   cout  lt  lt   bit 5 is    lt  lt  BitParser  getBitAt buffer  5   lt  lt  endl    Assuming I created the BitParser class  What would the BitParser class definition look like

User · Answer

Can I write something like static class   No  according to the C  11 N3337 standard draft Annex C 7 1 1      Change  In C     the static or extern specifiers can only be applied to names of objects or functions    Using these specifiers with type declarations is illegal in C     In C  these specifiers are ignored when used   on type declarations  Example   static struct S         valid C  invalid in C     int i           Rationale  Storage class specifiers don   t have any meaning when associated with a type  In C     class   members can be declared with the static storage class specifier  Allowing storage class specifiers on type   declarations could render the code confusing for users    And like struct  class is also a type declaration   The same can be deduced by walking the syntax tree in Annex A   It is interesting to note that static struct was legal in C  but had no effect  Why and when to use static structures in C programming

User · Answer

If you re looking for a way of applying the  static  keyword to a class  like you can in C  for example   static classes are just the compiler hand-holding you and stopping you from writing any instance methods variables   If you just write a normal class without any instance methods variables  it s the same thing  and this is what you d do in C

User · Answer

In Managed C    static class syntax is -  public ref class BitParser abstract sealed       public          static bool GetBitAt                                                  better late than never

User · Answer

You  can  have a static class in C    as mentioned before  a static class is one that does not have any objects of it instantiated it   In C    this can be obtained by declaring the constructor destructor as private   End result is the same

User · Answer

Unlike other managed programming language   static class  has NO meaning in C    You can make use of static member function

User · Answer

This is similar to C  s way of doing it in C    In C  file cs you can have private var inside a public function  When in another file you can use it by calling the namespace with the function as in   MyNamespace Function blah     Here s how to imp the same in 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

User · Answer

As it has been noted here  a better way of achieving this in C   might be using namespaces  But since no one has mentioned the final keyword here  I m posting what a direct equivalent of static class from C  would look like in C  11 or later   class BitParser final   public    BitParser     delete     static bool GetBitAt int buffer  int pos       bool BitParser  GetBitAt int buffer  int pos         your code

User · Answer

In C   you want to create a static function of a class  not a static class    class BitParser   public          static     getBitAt                 You should then be able to call the function using BitParser  getBitAt   without instantiating an object which I presume is the desired result

User · Answer

Consider Matt Price s solution    In C    a  static class  has no meaning  The nearest thing is a class with only static methods and members  Using static methods will only limit you    What you want is  expressed in C   semantics  to put your function  for it is a function  in a namespace   Edit 2011-11-11  There is no  static class  in C    The nearest concept would be a class with only static methods  For example      header class MyClass      public         static void myMethod             source void MyClass  myMethod           etc      But you must remember that  static classes  are hacks in the Java-like kind of languages  e g  C   that are unable to have non-member functions  so they have instead to move them inside classes as static methods   In C    what you really want is a non-member function that you ll declare in a namespace      header namespace MyNamespace      void myMethod           source namespace MyNamespace      void myMethod                 etc           Why is that   In C    the namespace is more powerful than classes for the  Java static method  pattern  because    static methods have access to the classes private symbols private static methods are still visible  if inaccessible  to everyone  which breaches somewhat the encapsulation static methods cannot be forward-declared static methods cannot be overloaded by the class user without modifying the library header there is nothing that can be done by a static method that can t be done better than a  possibly friend  non-member function in the same namespace namespaces have their own semantics  they can be combined  they can be anonymous  etc   etc    Conclusion  Do not copy paste that Java C  s pattern in C    In Java C   the pattern is mandatory  But in C    it is bad style   Edit 2010-06-10  There was an argument in favor to the static method because sometimes  one needs to use a static private member variable   I disagree somewhat  as show below   The  Static private member  solution     HPP  class Foo      public         void barA        private         void barB           static std  string myGlobal         First  myGlobal is called myGlobal because it is still a global private variable  A look at the CPP source will clarify that      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         At first sight  the fact the free function barC can t access Foo  myGlobal seems a good thing from an encapsulation viewpoint    It s cool because someone looking at the HPP won t be able  unless resorting to sabotage  to access Foo  myGlobal   But if you look at it closely  you ll find that it is a colossal mistake  Not only your private variable must still be declared in the HPP  and so  visible to all the world  despite being private   but you must declare in the same HPP all  as in ALL  functions that will be authorized to access it      So using a private static member is like walking outside in the nude with the list of your lovers tattooed on your skin   No one is authorized to touch  but everyone is able to peek at  And the bonus  Everyone can have the names of those authorized to play with your privies   private indeed     -D  The  Anonymous namespaces  solution  Anonymous namespaces will have the advantage of making things private really private   First  the HPP header     HPP  namespace Foo      void barA         Just to be sure you remarked  There is no useless declaration of barB nor myGlobal  Which means that no one reading the header knows what s hidden behind barA   Then  the 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         As you can see  like the so-called  static class  declaration  fooA and fooB are still able to access myGlobal  But no one else can  And no one else outside this CPP knows fooB and myGlobal even exist   Unlike the  static class  walking on the nude with her address book tattooed on her skin the  anonymous  namespace is fully clothed  which seems quite better encapsulated AFAIK   Does it really matter   Unless the users of your code are saboteurs  I ll let you  as an exercise  find how one can access to the private part of a public class using a dirty behaviour-undefined hack      what s private is private  even if it is visible in the private section of a class declared in a header   Still  if you need to add another  private function  with access to the private member  you still must declare it to all the world by modifying the header  which is a paradox as far as I am concerned  If I change the implementation of my code  the CPP part   then the interface  the HPP part  should NOT change  Quoting Leonidas    This is ENCAPSULATION    Edit 2014-09-20  When are classes static methods are actually better than namespaces with non-member functions   When you need to group together functions and feed that group to a template   namespace alpha      void foo        void bar        struct Beta      static void foo        static void bar         template  lt typename T gt  struct Gamma      void foobar              T  foo           T  bar              Gamma lt alpha gt  ga      compilation error Gamma lt Beta gt  gb       ok gb foobar            ok       Because  if a class can be a template parameter  a namespaces cannot

User · Answer

One  of the many  alternative  but the most  in my opinion  elegant  in comparison to using namespaces and private constructors to emulate the static behavior   way to achieve the  class that cannot be instantiated  behavior in C   would be to declare a dummy pure virtual function with the private access modifier   class Foo      public       static int someMethod int someArg       private       virtual void   dummy     0       If you are using C  11  you could go the extra mile to ensure that the class is not inherited  to purely emulate the behavior of a static class  by using the final specifier in the class declaration to restrict the other classes from inheriting it      C  11 ONLY class Foo final      public       static int someMethod int someArg       private        virtual void   dummy     0       As silly and illogical as it may sound  C  11 allows the declaration of a  pure virtual function that cannot be overridden   which you can use alongside declaring the class final to purely and fully implement the static behavior as this results in the resultant class to not be inheritable and the dummy function to not be overridden in any way      C  11 ONLY class Foo final      public       static int someMethod int someArg       private          Other private declarations       virtual void   dummy     0 final        Foo now exhibits all the properties of a static class

User · Answer

If you re looking for a way of applying the  static  keyword to a class  like you can in C  for example  then you won t be able to without using Managed C     But the looks of your sample  you just need to create a public static method on your BitParser object  Like so   BitParser h  class BitParser    public    static bool getBitAt int buffer  int bitIndex            lots of great stuff   private       Disallow creating an instance of this object   BitParser           BitParser cpp  bool BitParser  getBitAt int buffer  int bitIndex      bool isBitSet   false          determine if bit is set   return isBitSet      You can use this code to call the method in the same way as your example code   Hope that helps  Cheers

User · Answer

You can also create a free function in a namespace   In BitParser h  namespace BitParser       bool getBitAt int buffer  int bitIndex       In BitParser cpp  namespace BitParser       bool getBitAt int buffer  int bitIndex                  get the bit              In general this would be the preferred way to write the code  When there s no need for an object don t use a class

User · Answer

One case where namespaces may not be so useful for achieving  static classes  is when using these classes to achieve composition over inheritance  Namespaces cannot be friends of classes and so cannot access private members of a class   class Class    public    void foo     Static  bar  this           private    int member 0     friend class Static          class Static    public    template  lt typename T gt    static void bar T amp  t        t member   1

[c++] How do you create a static class in C++?

Examples related to c++

Examples related to oop

Examples related to class

Examples related to syntax

Examples related to static