Metin2'yi özgür bırakın!

TheAdmin33 · 3 May 2025

C++:

#ifndef __INC_SINGLETON_H__
#define __INC_SINGLETON_H__

#include <cassert>

template <typename T> class singleton
{
    protected:
        static T* ms_singleton;

    public:
        singleton()
        {
            assert(!ms_singleton);
            ms_singleton = static_cast<T*>(this);
        }

        virtual ~singleton()
        {
            assert(ms_singleton);
            ms_singleton = nullptr;
        }

        static T& instance()
        {
            assert(ms_singleton);
            return *ms_singleton;
        }

        static T& Instance()
        {
            return instance();
        }

        static T* instance_ptr()
        {
            return ms_singleton;
        }

        singleton(const singleton&) = delete;
        singleton& operator=(const singleton&) = delete;

        singleton(singleton&&) = delete;
        singleton& operator=(singleton&&) = delete;
};

template <typename T> T* singleton <T>::ms_singleton = nullptr;

#endif

C++:

#ifndef __INC_SINGLETON_H__
#define __INC_SINGLETON_H__
#pragma once

#include <cassert>

#if !defined(WIN32) && !defined(__forceinline)
#define __forceinline __attribute__((always_inline))
#endif

template <typename T> class CSingleton
{
    static inline T * ms_singleton = nullptr;

public:
    CSingleton()
    {
        assert(!ms_singleton);
        ms_singleton = static_cast<T*>(this);
    }

    virtual ~CSingleton()
    {
        assert(ms_singleton);
        ms_singleton = nullptr;
    }

    __forceinline static T & Instance()
    {
        assert(ms_singleton);
        return (*ms_singleton);
    }

    __forceinline static T * InstancePtr()
    {
        return (ms_singleton);
    }

    __forceinline static T & instance()
    {
        assert(ms_singleton);
        return (*ms_singleton);
    }

    __forceinline static T * instance_ptr()
    {
        return (ms_singleton);
    }

    // prevent manager 0x0 by deleting copy/assignment operators
    CSingleton(const CSingleton&) = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    CSingleton(CSingleton&&) = delete;
    CSingleton& operator=(CSingleton&&) = delete;
};

template <typename T>
using singleton = CSingleton<T>;

#endif
//martysama0134's 8e0aa8057d3f54320e391131a48866b4

loyit120 · 3 May 2025

Herkes elindekini paylaşıyor buda benden olsun belki birinin işini görür

Kod:

#ifndef __INC_SINGLETON_H__
#define __INC_SINGLETON_H__
#pragma once

#include <memory>

template <typename T>
class CSingleton
{
public:
    static T& instance()
    {
        static T instance;
        return instance;
    }

    static T* instance_ptr()
    {
        return &instance();
    }

    CSingleton(const CSingleton&) = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    CSingleton(CSingleton&&) = delete;
    CSingleton& operator=(CSingleton&&) = delete;

protected:
    CSingleton() = default;
    virtual ~CSingleton() = default;
};

template <typename T>
using singleton = CSingleton<T>;

#endif // __INC_SINGLETON_H__

dormammu · 3 May 2025

loyit120' Alıntı:

Herkes elindekini paylaşıyor buda benden olsun belki birinin işini görür

Kod:

#ifndef __INC_SINGLETON_H__
#define __INC_SINGLETON_H__
#pragma once

#include <memory>

template <typename T>
class CSingleton
{
public:
    static T& instance()
    {
        static T instance;
        return instance;
    }

    static T* instance_ptr()
    {
        return &instance();
    }

    CSingleton(const CSingleton&) = delete;
    CSingleton& operator=(const CSingleton&) = delete;
    CSingleton(CSingleton&&) = delete;
    CSingleton& operator=(CSingleton&&) = delete;

protected:
    CSingleton() = default;
    virtual ~CSingleton() = default;
};

template <typename T>
using singleton = CSingleton<T>;

#endif // __INC_SINGLETON_H__

Herkesin singleton u kendine