TStaticPtr.h

Ir a la documentación de este archivo.

 
/*
 * MIT License
 *
 * Copyright (c) 2025 Roberto Charreton
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * In addition, any project or software that uses this library or class must include
 * the following acknowledgment in the credits:
 *
 * "This project uses software developed by Roberto Charreton and Attribute Overload."
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
*/
#pragma once
namespace EU {
  template<typename T>
  class TStaticPtr {
  public:
    TStaticPtr() = default;
 
    explicit TStaticPtr(T* rawPtr) {
      if (instance != nullptr) {
        delete instance;
      }
      instance = rawPtr;
    }
 
    ~TStaticPtr() {
      if (instance != nullptr) {
        delete instance;
        instance = nullptr;
      }
    }
 
    static T*
      get() {
      return instance;
    }
 
    static bool
      isNull() {
      return instance == nullptr;
    }
 
    static void
      reset(T* rawPtr = nullptr) {
      if (instance != nullptr) {
        delete instance;
      }
      instance = rawPtr;
    }
 
  private:
    static T* instance; 
  };
 
  /*
  // Inicializar el puntero estático
  template<typename T>
  T* TStaticPtr<T>::instance = nullptr;
 
  // Ejemplo de uso de TStaticPtr
  class MyClass
  {
  public:
    MyClass(int value) : value(value)
    {
      std::cout << "MyClass constructor: " << value << std::endl;
    }
 
    ~MyClass()
    {
      std::cout << "MyClass destructor: " << value << std::endl;
    }
 
    void display() const
    {
      std::cout << "Value: " << value << std::endl;
    }
 
  private:
    int value;
  };
 
  int main()
  {
    {
      // Crear un TStaticPtr usando un puntero crudo
      TStaticPtr<MyClass>::reset(new MyClass(10));
      TStaticPtr<MyClass>::get()->display(); // Output: Value: 10
 
      // Comprobar si el puntero no es nulo
      if (!TStaticPtr<MyClass>::isNull())
      {
        std::cout << "TStaticPtr is not null" << std::endl;
      }
 
      // Reiniciar TStaticPtr con un nuevo objeto
      TStaticPtr<MyClass>::reset(new MyClass(20));
      TStaticPtr<MyClass>::get()->display(); // Output: Value: 20
 
      // Reiniciar con nullptr
      TStaticPtr<MyClass>::reset();
      if (TStaticPtr<MyClass>::isNull())
      {
        std::cout << "TStaticPtr is null after reset" << std::endl;
      }
    }
 
    return 0;
  }
  */
}