如何在C++中为单例（Singleton）构造函数传入int类型参数

Alright, let's tackle how to pass an int parameter to your Proxy singleton's constructor. Looking at your existing code, there are a few gaps and tweaks we need to make to get this working correctly while maintaining the singleton pattern.

Key Issues in Your Current Code #

• The getInstance() method doesn't accept any parameters, so there's no way to pass the int to the constructor.
• The constructor declaration in the header is incomplete (Proxy(...), and we need to explicitly define a private, parameterized constructor.
• The singleton instance isn't being initialized with any logic to handle the input parameter.

Step-by-Step Solution #

1. Fix the Proxy Header File (Proxy.h)

First, we'll update the header to declare a private parameterized constructor, add proper singleton safeguards, and adjust getInstance() to accept the int parameter:

#ifndef PROXY_H
#define PROXY_H
#include "Generator.h"

class Proxy : private Generator {
public:
    ~Proxy();
    // Updated getInstance to accept the int parameter
    static Proxy* getInstance(int inputbits);
    // Optional: Overload for subsequent calls without passing the parameter
    static Proxy* getInstance();
    
    Generator* operator->();

private:
    // Private parameterized constructor (matches your existing implementation)
    explicit Proxy(int inputbits);
    
    // Disable copy constructor and assignment operator to enforce singleton
    Proxy(const Proxy&) = delete;
    Proxy& operator=(const Proxy&) = delete;

    // Static instance pointer (only needed if using the dynamic allocation approach)
    static Proxy* instance;
    int counter = 0; // Assuming you need this for your operator-> logic
};

#endif // PROXY_H

2. Implement the Proxy Class (Proxy.cpp)

Now, let's implement the logic to initialize the singleton with the input parameter. We'll cover two common approaches:

Approach 1: Dynamic Allocation (Traditional Singleton)

This uses a static pointer to the instance, initialized once when getInstance() is first called:

#include "Proxy.h"
#include "Generator.h"
#include <cassert>

// Initialize static instance pointer to null
Proxy* Proxy::instance = nullptr;

// Constructor implementation (passes inputbits to Generator's constructor)
Proxy::Proxy(int inputbits) : Generator(inputbits), counter(0) {}

Proxy::~Proxy() {}

Proxy* Proxy::getInstance(int inputbits) {
    if (!instance) {
        // Only initialize if the instance doesn't exist yet
        instance = new Proxy(inputbits);
    }
    // Optional: Add a check to ensure subsequent calls use the same parameter
    // assert(/* compare inputbits to stored value if needed */ && "Mismatched singleton parameters!");
    return instance;
}

// Overloaded getInstance for subsequent calls (no parameter needed)
Proxy* Proxy::getInstance() {
    // Ensure the singleton was already initialized with the parameterized call
    assert(instance != nullptr && "Call getInstance(int) first to initialize the singleton!");
    return instance;
}

Generator* Proxy::operator->() {
    if (counter <= 10) {
        counter++; // Don't forget to increment your counter!
        return this; // Proxy inherits from Generator, so return this directly
    } else {
        return nullptr;
    }
}

Approach 2: Static Local Object (Recommended)

This approach is safer because the static local object is automatically destroyed when the program exits, avoiding memory leaks. It's also thread-safe in C++11 and later:

First, adjust the header to remove the static instance pointer:

// Remove this line from Proxy.h:
// static Proxy* instance;

Then update the getInstance() implementation:

#include "Proxy.h"
#include "Generator.h"
#include <cassert>

// Constructor implementation
Proxy::Proxy(int inputbits) : Generator(inputbits), counter(0) {}

Proxy::~Proxy() {}

static bool isSingletonInitialized = false;

Proxy* Proxy::getInstance(int inputbits) {
    // Static local object: initialized once on first call, destroyed automatically
    static Proxy instance(inputbits);
    isSingletonInitialized = true;
    return &instance;
}

// Overloaded getInstance for subsequent calls
Proxy* Proxy::getInstance() {
    assert(isSingletonInitialized && "Call getInstance(int) first to initialize the singleton!");
    return getInstance(0); // Dummy value, won't affect the already initialized instance
}

Generator* Proxy::operator->() {
    if (counter <= 10) {
        counter++;
        return this;
    } else {
        return nullptr;
    }
}

Usage Example #

// First call: Initialize the singleton with your int parameter
Proxy* proxy = Proxy::getInstance(16);

// Subsequent calls: Use the overloaded getInstance without parameters
Proxy* sameProxy = Proxy::getInstance();

// Use the proxy (assuming Generator has methods like generate())
sameProxy->generate();

Important Notes #

• The singleton's parameter can only be set once (on the first call to getInstance(int)). Subsequent calls can't change it.
• If you need to enforce that all calls use the same parameter, add a static member variable to store the initial input, then compare it against new inputs in getInstance(int).
• The static local object approach is preferred for its safety and built-in thread-safety (no manual memory management required).

内容的提问来源于stack exchange，提问作者Gideok Seong