相关疑难解决方法(0)

我正在建立一个基于约书亚建设者模式的建设者.我的问题是如何让它成为单身人士？详细阐述我的观点,如果我有下面的建设者

public class Widget {
    public static class Builder {
        private String name;

        public Builder( String name) {
            this.name = name;
        }

        public Widget build() {
            Widget result = new Widget(this);
            return result;
        }
        public Builder model( String value ) {
            this.model = value;
            return this;
        }
    }

    private final String name;

    private Widget( Builder b ) {
        this.name = b.name;
    }

    // ... etc. ...
}

我会从另一个类中调用此构建器,如新的Widget.Builder().name("abc").build()........

但是如果我只想要这个Widget的一个实例,或者我需要从多个地方访问这个Widget而不需要每次都创建一个新的Widget.理想情况下,我想将实例化限制在Widget类中.有什么想法吗？

我试图创建一个单身时想出了这个.示例:(我正在尝试创建MySelf一个单例,它是线程安全的,不使用双重检查锁定)

class MySelf
{
private:
    string Name;
    int Age;

    MySelf()
    {
        Name = "Deamonpog";
        Age = 24;
        cout << "Constructing MySelf : " << Name << endl;
    };

    friend class MySingleton;

public:
    ~MySelf(){ cout << "Destructing MySelf : " << Name << endl; };

    int MyAge() const
    {
        return Age;
    }
};

class MySingleton
{
private:
    static MySelf mself;
public:
    static MySelf * GetInstance()
    {
        return &mself;
    }
};

MySelf MySingleton::mself;

现在我可以很容易地使用它,像

cout << "I am " << …

当Singleton设计模式优于静态类并且静态类优于Singleton设计模式时,有哪些情况？

我有一个将作为单身人士的课程.
该类将获取一个文件作为构造函数的一部分.之后,课程准备好了.
因此,目前我使用双重检查锁定惯用法并通过static getInstance()经典方式获得单例的实例.
我的问题是,目前我经常这样做:

MySingleton.getInstance(theFile);

并且theFile仅在第一次构造单身时才需要.在那之后,即一旦构建了单身人士,我就不需要传递theFile.
我该怎么办？
我想创建一个MySingleton.getInstance(); 但仍然无法工作,因为调用者必须MySingleton.getInstance(theFile); 第一次调用构造一个有效的类.
我怎样才能更好地设计它？

在 Facade 和 Singleton 的描述中，您可以读到：“Facade 通常被实现为单例”。

我想知道什么时候应该将 Facade 实现为单例，什么时候这是一个坏主意。

class MyClass
{
    private MyClass(){}

    private static MyClass instance;

    public static MyClass Instance
    {
       get
       {
          return instance=instance??new MyClass();
       }
    }
}

我目前正在开发一个“Singleton”类，但它必须承受线程安全，因为我不仅要访问，还要设置一些东西。lock(object)当我不知道它实际上在做什么以及我是否必须使每个方法线程安全时，感觉有点笨拙？

到目前为止，我有这个非线程安全代码 - 因为在每个线程中都应该访问相同的数据。我将如何最好地使其线程安全并保持单例？

public class AppSession() {
    private static AppSession _instance = new AppSession();
    public static AppSession Instance { get { return _instance; } }

    private AppSession() { }

    private string _actionName = "none";
    private DateTime? _actionTime = null;        
    public void ActionExecuted(string action) {
        _actionName = action ?? String.Empty;
        _actionTime = DateTime.UtcNow;
    }

    public LastAction {
       get { return $"{_action} at {_actionTime?.Value.ToString()}"; }
    }
}

如果一个类实现了单例模式,那么所有变量都应该声明为static吗？

有什么理由不应该被宣布为静态吗？这有什么不同吗？

通常当我实现单例时,我使实例动态化,并有一个成员函数来删除它.在这种情况下,我正在使用嵌入式设备,我被告知我不能使用动态内存.它对一个类在类声明中有自己的静态实例是有效的,并通过引用返回它？

(此处不关注线程安全性.)

class Foo {
private:
    static Foo singleton;

    Foo() { }
    Foo(const Foo &rhs);
    Foo &operator=(const Foo &rhs);

public:
    inline static Foo &Instance(void) {
        return singleton;
    }
};

Foo Foo::singleton;

我应该如何为我的单例类编写一个复制构造函数,以防止创建一个新对象,因为我已经有了一个.什么是overload = operator的最佳实践

 #include <iostream>
 #include <stdio.h>
 #include <conio.h>

 using namespace std;

 class Rect
 { 
  int length;
  int breadth;
  static int count;
  static int maxcount;
  Rect()
  {};
  Rect(const Rect& abc){};
  public :

      ~Rect();
      int area_rect()          
      {return length*breadth;}
      void set_value(int a,int b);

      static Rect* instance()
      {     
            Rect* ptr=NULL;
            if(count < maxcount)
            {
              ptr=new Rect ;
              count++;
            }
             return ptr;
       }
     };
    int Rect::count = 0;
    int Rect::maxcount = 1;
    void Rect::set_value(int a,int b)
   {
    length=a;
    breadth=b;
   }
  Rect::~Rect()
  {
   count --; …