Documentation

    Table of Content
    • CodePorting.Native Product Family
      • CodePorting.Native Cs2Cpp
        • Getting Started
          • Product Overview
          • Installation
          • Licensing
          • How to use CodePorting.Native Cs2Cpp
            • How to Use Command line to port and build Projects
            • How to Use GUI to port and build Projects
        • Developer Guide
          • Porting Simple C# Projects
            • Porting Simple Console Application
            • Porting Simple Library
            • Porting Simple NUnit Test
          • Porting Dependent C# Projects
            • Porting Dependent Console Application
            • Porting Dependent Library
            • Porting Dependent NUnit Test
          • Porting Complex C# Projects
            • How to Convert Complex C# Console Application to C++
            • How to Convert Complex C# Library to C++
            • How to Convert Complex C# NUnit Test to C++
          • Qt support
          • What Converts to What
            • AbstractClasses
            • BreakStatements
            • ClassAutoProperties
            • ClassConstructors
            • ClassEvents
            • ClassFinalizers
            • ClassGenericMethods
            • ClassIndexers
            • ClassMethods
            • ClassProperties
            • ClassStaticConstructor
            • ClassStaticMethods
            • ClassStaticProperties
            • ClassVirtualMethods
            • ContinueStatements
            • Delegates
            • DoWhileStatements
            • Enums
            • EnumTypeCast
            • Exceptions
            • ExpectedException
            • ForeachStatements
            • ForeachStatementsStd
            • ForStatements
            • GenericClasses
            • GenericDelegates
            • GenericInterfaces
            • GenericStructs
            • IfStatements
            • LambdaExpressions
            • NestedClasses
            • ReturnStatements
            • SimpleClass
            • SimpleInterface
            • SimpleStruct
            • SimpleTest
            • StandardTypeCast
            • StaticClass
            • SwitchStatements
            • TestWithSetupMethods
            • ThrowStatements
            • TryCatchFinallyStatements
            • TryCatchStatements
            • TryFinallyStatements
            • VarExpressions
            • WhileStatements
          • CodePorting Native Cs2Cpp Attributes
          • CodePorting Native Cs2Cpp Configuration File
            • CodePorting.Native Cs2Cpp Configuration File Structure
            • Attributes in Configuration file
            • Configuration file Nodes
            • Configuration file Options
          • Memory Management Model
            • Memory Management Model Description
            • Using aliasing constructor to create a smart pointer
          • Cmake Support
          • C++ code injection
          • C++ user-defined exception classes
          • Limitations and Bugs
            • Porter Limitations and Bugs
            • Library Limitations and Bugs
            • Cpp Code Injection
        • Release Notes
          • 2022
            • CodePorting.Native Cs2Cpp 22.5
            • CodePorting.Native Cs2Cpp 22.4
            • CodePorting.Native Cs2Cpp 22.3
            • CodePorting.Native Cs2Cpp 22.2
            • CodePorting.Native Cs2Cpp 22.1
          • 2021
            • CodePorting.Native Cs2Cpp 21.12
            • CodePorting.Native Cs2Cpp 21.11
            • CodePorting.Native Cs2Cpp 21.10.1
            • CodePorting.Native Cs2Cpp 21.10
            • CodePorting.Native Cs2Cpp 21.9
            • CodePorting.Native Cs2Cpp 21.8
            • CodePorting.Native Cs2Cpp 21.7
            • CodePorting.Native Cs2Cpp 21.6
            • CodePorting.Native Cs2Cpp 21.5
            • CodePorting.Native Cs2Cpp 21.4
            • CodePorting.Native Cs2Cpp 21.3
            • CodePorting.Native Cs2Cpp 21.2
            • CodePorting.Native Cs2Cpp 21.1
          • 2020
            • CodePorting.Native Cs2Cpp 20.12
            • CodePorting.Native Cs2Cpp 20.11
            • CodePorting.Native Cs2Cpp 20.10
            • CodePorting.Native Cs2Cpp 20.9
            • CodePorting.Native Cs2Cpp 20.8
            • CodePorting.Native Cs2Cpp 20.7
            • CodePorting.Native Cs2Cpp 20.6
            • CodePorting.Native Cs2Cpp 20.5
            • CodePorting.Native Cs2Cpp 20.4
            • CodePorting.Native Cs2Cpp 20.3
            • CodePorting.Native Cs2Cpp 20.2
            • CodePorting.Native Cs2Cpp 20.1
          • 2019
            • CodePorting.Native Cs2Cpp 19.1
            • CodePorting.Native Cs2Cpp 19.2
            • CodePorting.Native Cs2Cpp 19.3
            • CodePorting.Native Cs2Cpp 19.4
            • CodePorting.Native Cs2Cpp 19.4.1
            • CodePorting.Native Cs2Cpp 19.5
            • CodePorting.Native Cs2Cpp 19.6
            • CodePorting.Native Cs2Cpp 19.7
            • CodePorting.Native Cs2Cpp 19.8
            • CodePorting.Native Cs2Cpp 19.9
            • CodePorting.Native Cs2Cpp 19.10
            • CodePorting.Native Cs2Cpp 19.11
            • CodePorting.Native Cs2Cpp 19.12
          • 2018
            • CodePorting.Native Cs2Cpp 18.9
            • CodePorting.Native Cs2Cpp 18.9.1
            • CodePorting.Native Cs2Cpp 18.10
            • CodePorting.Native Cs2Cpp 18.11
            • CodePorting.Native Cs2Cpp 18.12
    1. Home
    2. CodePorting.Native Product Family
    3. CodePorting.Native Cs2Cpp
    4. Developer Guide
    5. What Converts to What
    6. ClassStaticConstructor

    ClassStaticConstructor

    What's on this Page

      • Source C# Code
      • Ported Code
        • C++ Header
        • C++ Source Code

    This example demonstrates how static class constructor is ported to C++. A static field with special name s_constructor__ of special type __StaticConstructor__ is added. The code is executed on program startup and this behavior is different from C# static constructors which are called right before first class usage.

    Additional command-line options passed to CsToCppPorter: none.

    Source C# Code

    using NUnit.Framework;
    
    
    namespace MembersPorting
    {
        public class ClassStaticConstructor
        {
            static ClassStaticConstructor()
            {
            }
        }
    
        public static class DeletedConstructor
        {
            static void Foo() { }
        }
    
        public static class StaticConstructorExists
        {
            static readonly bool Foo;
    
            static void Bar() { }
    
            static StaticConstructorExists()
            {
                Foo = false;
            }
        }
    
        [TestFixture]
        public static class NonDeletedConstructor { }
    
        [CsToCppPorter.CppDeferredInit]
        internal static class SlidesIssue
        {
            static SlidesIssue() {}
        }
    }

    Ported Code

    C++ Header

    #pragma once
    
    #include <system/object.h>
    #include <mutex>
    #include <memory>
    #include <gtest/gtest.h>
    
    namespace MembersPorting {
    
    class ClassStaticConstructor : public System::Object
    {
        typedef ClassStaticConstructor ThisType;
        typedef System::Object BaseType;
        
        typedef ::System::BaseTypesInfo<BaseType> ThisTypeBaseTypesInfo;
        RTTI_INFO_DECL();
        
    private:
    
        static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;
        
    };
    
    class DeletedConstructor
    {
        typedef DeletedConstructor ThisType;
        
    private:
    
        static void Foo();
        
    public:
        DeletedConstructor() = delete;
    };
    
    class StaticConstructorExists
    {
        typedef StaticConstructorExists ThisType;
        
    private:
    
        static bool Foo;
        
        static void Bar();
        
        static struct __StaticConstructor__ { __StaticConstructor__(); } s_constructor__;
        
    public:
        StaticConstructorExists() = delete;
    };
    
    class NonDeletedConstructor
    {
        typedef NonDeletedConstructor ThisType;
        
    };
    
    class SlidesIssue
    {
        typedef SlidesIssue ThisType;
        
    public:
    
        SlidesIssue();
        
    private:
    
        static void __StaticConstructor__();
        
    };
    
    } // namespace MembersPorting
    

    C++ Source Code

    #include "ClassStaticConstructor.h"
    
    namespace MembersPorting {
    
    RTTI_INFO_IMPL_HASH(2828145692u, ::MembersPorting::ClassStaticConstructor, ThisTypeBaseTypesInfo);
    
    ClassStaticConstructor::__StaticConstructor__ ClassStaticConstructor::s_constructor__;
    
    ClassStaticConstructor::__StaticConstructor__::__StaticConstructor__()
    {
    }
    
    void DeletedConstructor::Foo()
    {
    }
    
    bool StaticConstructorExists::Foo = false;
    
    StaticConstructorExists::__StaticConstructor__ StaticConstructorExists::s_constructor__;
    
    void StaticConstructorExists::Bar()
    {
    }
    
    StaticConstructorExists::__StaticConstructor__::__StaticConstructor__()
    {
        StaticConstructorExists::Foo = false;
    }
    
    namespace gtest_test
    {
    
    class NonDeletedConstructor : public ::testing::Test
    {
    protected:
        static void SetUpTestCase()
        {
        };
        
        static void TearDownTestCase()
        {
        };
        
    };
    
    } // namespace gtest_test
    
    void SlidesIssue::__StaticConstructor__()
    {
        thread_local static bool inProgress = false;
        if (inProgress) return;
        static const auto markFinished = [](bool *inProgress) { *inProgress = false; };
        inProgress = true;
        const std::unique_ptr<bool, decltype(markFinished)> finish(&inProgress, markFinished);
        
        static std::once_flag once;
        std::call_once(once, []
        {
        });
    }
    
    SlidesIssue::SlidesIssue()
    {
        __StaticConstructor__();
        
    }
    
    } // namespace MembersPorting