Bug Report: System fails when object lacks defaults constructor.

[gem870]

Describe the bug
When declaring a class with only a parameterized constructor, the system throws an error or fails during instantiation. This seems to occur when the framework or serialization logic expects a default (no-argument) constructor.

To Reproduce
Steps to reproduce the behavior:

• Create a class with only a constructor that takes parameters.
• Attempt adding the object using the addItem() function.
• Observe the failure or exception.

Example Code:

    class Product {
        public:
          Product(std::string name, double price) : name(name), price(price) {}
  
        private:
          std::string name;
          double price;
    };

Expected behavior
The system should either handle parameterized constructors gracefully or provide a clear error message. Alternatively, documentation should specify that a default constructor is required.

Workaround:
Add a default constructor manually:

    Product() : name(""), price(0.0) {}

Additional Notes:
This issue may affect serialization, deserialization, or object pooling mechanisms that rely on default instantiation.

[gem870]

Hi dear, Your approach is nice, but what I want to achieve here is this: I want Smart_Store to be able to maintain the integrity and deserialization of every single object that has a default constructor or not, without breaking down.

…

On Sun, Oct 26, 2025 at 1:56 PM Moin Shaikh ***@***.***> wrote: *Moin2002-tech* left a comment (gem870/Smart_Store#3) <#3 (comment)> use Default for Contructor `class Product { public: Product() = default; // Explicitly generates the default constructor // ... rest of the code };` — Reply to this email directly, view it on GitHub <#3 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/A5PBQ447HRCR5FRHA5W5C3T3ZTAHXAVCNFSM6AAAAACEUV5QEKVHI2DSMVQWIX3LMV43OSLTON2WKQ3PNVWWK3TUHMZTINBYGQ4TIOJVGE> . You are receiving this because you authored the thread.Message ID: ***@***.***>

[Moin2002-tech]

Constructor Trap Workaround
Hey @gem870, thanks for logging this. You hit the nail on the head—this is the classic C++ integrity clash. The framework has to allocate memory before loading data, and when it can't find a public default constructor, it throws a fit.

The simple manual workaround (Product() : name("")) works, but it breaks our core integrity rule by allowing the creation of a public, uninitialized object.

The permanent, robust fix is to use Boost's Split Member Serialization. This technique lets us handle the memory allocation secretly while retaining full control over the final object state.

So can we use external Library boost.serialization ?

[gem870]

Hey @Moin2002-tech, thanks a lot for your suggestion — I really appreciate your input!

You're right about the issue with default constructors. It’s a common problem in C++ when a system tries to create an object but can’t find a simple constructor with no parameters. Your idea of using Boost’s Split Member Serialization is a solid one — it’s powerful and solves the problem well.

But here’s the direction I’m thinking for Smart_Store: I want to keep it lightweight and easy to use, especially for developers who don’t want to deal with external libraries like Boost. So instead of relying on Boost, I’m exploring a method called semantic move using lambda functions.

This approach works like this:

• We save the current state of an object (like its name, position, or price).
• Then we use a small function (a lambda) to rebuild the object using that saved state.
• This lets us undo changes or restore objects without needing a default constructor.

It’s clean, flexible, and doesn’t require any extra libraries. Plus, it fits perfectly with Smart_Store’s undo/redo system.

After providing a minimal reproducible code of this project on Stack Overflow, someone hit this same spot with the following code:

#include <string>
#include <string_view>
#include <concepts>
#include <memory>
#include <stack>
#include <iostream>
#include <type_traits>

// restore actions should be nothrow... otherwise things
// get complicated really quickly ;)
template <typename F>
concept nothrow_invocable = requires(F f) {
    { f() } noexcept;
};

class IRestore
{
public:
    virtual ~IRestore() = default;
    virtual void Restore() noexcept = 0;
};

template <typename fn_t>
    requires nothrow_invocable<fn_t>
class RestoreImpl final : public IRestore
{
public:
    RestoreImpl(fn_t fn)
        : m_fn{fn}
    {
    }

    void Restore() noexcept override
    {
        m_fn();
    }

private:
    fn_t m_fn;
};

class RestoreStack
{
public:
    template <typename fn_t>
        requires nothrow_invocable<fn_t>
    void Push(fn_t fn)
    {
        m_stack.push(std::move(std::make_unique<RestoreImpl<fn_t>>(fn)));
    }

    void Pop()
    {
        std::unique_ptr<IRestore> top{std::move(m_stack.top())};
        m_stack.pop();
        top->Restore();
    }

private:
    std::stack<std::unique_ptr<IRestore>> m_stack;
};

class SomeClass
{
public:
    // this is not strictly necessary, but makes it easier
    // to maintain which members should participate in 
    // restoring. (Easy to add more data later without refactoring
    // in a lot of places).
    struct RestorableState
    {
        std::string name;
        int x;
        int y;
    };

    SomeClass(const RestorableState& state) noexcept :
        m_state{state}
    {
    }

    const RestorableState& GetRestorableState() const noexcept
    {
        return m_state;
    }

    void set(int x, int y)
    {
        m_state.x = x;
        m_state.y = y;
    }

private:
    RestorableState m_state;

};

std::ostream& operator<<(std::ostream& os, const SomeClass& s)
{
    auto& state = s.GetRestorableState();
    os << state.name << " = { x = " << state.x << ", y = " << state.y << " }";
    return os;
}

int main()
{
    RestoreStack restore;

    SomeClass instance1{{"instance1", 1, 1}};
    
    std::cout << instance1 << "\n";
    
    // the lambda can now do anything to restore a state   
    restore.Push(
        [&, state = instance1.GetRestorableState()]() noexcept
        {
            // here is your call to the parameterized constructor
            instance1 = std::move(SomeClass{state});
        });

    std::cout << "Set\n";
    instance1.set(3, 3);
    std::cout << instance1 << "\n";

    std::cout << "Restore\n";
    restore.Pop();
    std::cout << instance1 << "\n";
}

I’d love to hear what you think about this approach. Maybe we can even build a hybrid system together — one that supports both Boost and semantic move, depending on what the user prefers.

[Moin2002-tech]

Hey @gem870,
This is such a clean and clever solution! Seriously, using the lambda to capture the state and then reconstruct the object entirely is a beautiful way to enforce invariants (rules that an object must always follow). You've basically built a lightweight, self-contained Command/Undo system without needing a single external library.

[gem870]

Thanks @Moin2002-tech: I’m really glad the approach resonates with you!

The idea of using lambdas to capture and restore state felt like a natural fit for Smart_Store’s architecture. It keeps things clean, avoids external dependencies, and gives us full control over object integrity, especially when default constructors aren’t available or desirable.

I’m thinking of expanding this into a more formal part of the framework, maybe a SmartRestoreStack module that developers can plug into their own systems. It could support chaining, batching, and even versioned state snapshots.

Would love to hear your thoughts on that. If you’re up for it, maybe we can sketch out a few use cases together. It could be a great way to showcase Smart_Store’s flexibility and push the boundaries of undo/redo in modern C++.

[Moin2002-tech]

I`d prefer both Boost and semantic move.
here is how we do I edited Reproducible code little bit for both hybrids one.

Msvc C++17
Visual Studio
Text Generated:
22 serialization::archive 20 0 0 9 Product A 10 20

#include <string>
#include <string_view>
#include <concepts> // Although included, the C++20 concepts usage is removed below.
#include <memory>
#include <stack>
#include <iostream>
#include <type_traits> // Required for C++17 SFINAE (is_nothrow_invocable_v)
#include <fstream>

// --- BOOST HEADERS FOR PERSISTENCE ---
// We use Boost to handle the file-based archiving (disk storage)
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/string.hpp> // Needed for std::string serialization

// ----------------------------------------------------------------------
// PART 1: IN-MEMORY UNDO/REDO (SEMANTIC MOVE / LAMBDA COMMAND PATTERN)
// ----------------------------------------------------------------------

// C++20 Concept removed. Using C++17 SFINAE below via std::enable_if_t
// which relies on std::is_nothrow_invocable_v to enforce the noexcept constraint.

// Base interface for a restorable command
class IRestore
{
public:
    virtual ~IRestore() = default;
    virtual void Restore() noexcept = 0;
};

// Template implementation that holds the lambda (the command).
// C++17 SFINAE constraint: requires fn_t to be nothrow invocable.
template <typename fn_t,
    typename = std::enable_if_t<std::is_nothrow_invocable_v<fn_t>>>
class RestoreImpl final : public IRestore
{
public:
    RestoreImpl(fn_t fn)
        : m_fn{ fn }
    {
    }

    void Restore() noexcept override
    {
        m_fn();
    }

private:
    fn_t m_fn;
};

// The core undo stack
class RestoreStack
{
public:
    // C++17 SFINAE constraint: requires fn_t to be nothrow invocable.
    template <typename fn_t,
        typename = std::enable_if_t<std::is_nothrow_invocable_v<fn_t>>>
    void Push(fn_t fn)
    {
        // Pushes the command (lambda) onto the stack
        m_stack.push(std::make_unique<RestoreImpl<fn_t>>(std::move(fn)));
    }

    void Pop()
    {
        if (m_stack.empty()) return;

        // 1. Get the command
        std::unique_ptr<IRestore> top{ std::move(m_stack.top()) };
        m_stack.pop();

        // 2. Execute the command (which calls the parameterized constructor
        //    with the saved state copy)
        top->Restore();
    }

private:
    std::stack<std::unique_ptr<IRestore>> m_stack;
};


// ----------------------------------------------------------------------
// PART 2: THE OBJECT AND STATE DEFINITION
// ----------------------------------------------------------------------

class SomeClass
{
public:
    // This RestorableState is the bridge between the two systems:
    // 1. It is copied/captured by the lambda for UNDO.
    // 2. It is saved/loaded by Boost for PERSISTENCE.
    struct RestorableState
    {
        std::string name;
        int x;
        int y;

    private:
        // Serialization method required by Boost
        friend class boost::serialization::access;
        template<class Archive>
        void serialize(Archive& ar, const unsigned int version)
        {
            // Boost handles saving/loading of the struct's members
            ar& name;
            ar& x;
            ar& y;
            // Note: versioning logic would be added here if needed
        }
    };

    // Parameterized constructor - ESSENTIAL for guaranteeing invariants on load/restore.
    SomeClass(const RestorableState& state) noexcept :
        m_state{ state }
    {
        // *** Invariant Check Example (Simplified) ***
        // if (state.x < 0 || state.y < 0) { throw std::invalid_argument("Coords cannot be negative."); }
        // The fact that this constructor runs on load/restore is the source of safety.
    }

    const RestorableState& GetRestorableState() const noexcept
    {
        return m_state;
    }

    void set(int x, int y)
    {
        // This is a mutable operation that we might want to undo
        m_state.x = x;
        m_state.y = y;
    }

private:
    RestorableState m_state;
};

std::ostream& operator<<(std::ostream& os, const SomeClass& s)
{
    auto& state = s.GetRestorableState();
    os << state.name << " = { x = " << state.x << ", y = " << state.y << " }";
    return os;
}

// ----------------------------------------------------------------------
// PART 3: BOOST PERSISTENCE IMPLEMENTATION
// ----------------------------------------------------------------------

// Function to save the RestorableState to a file
void SaveState(const SomeClass::RestorableState& state, const std::string& filename)
{
    try {
        std::ofstream ofs(filename);
        boost::archive::text_oarchive oa(ofs);
        oa << state;
        std::cout << "SUCCESS: State successfully saved to '" << filename << "'\n";
    }
    catch (const std::exception& e) {
        std::cerr << "ERROR SAVING: " << e.what() << "\n";
    }
}

// Function to load the RestorableState from a file
SomeClass::RestorableState LoadState(const std::string& filename)
{
    SomeClass::RestorableState loaded_state{};
    try {
        std::ifstream ifs(filename);
        if (!ifs.is_open()) {
            throw std::runtime_error("File not found.");
        }
        boost::archive::text_iarchive ia(ifs);
        ia >> loaded_state;
        std::cout << "SUCCESS: State loaded from '" << filename << "'\n";
    }
    catch (const std::exception& e) {
        std::cerr << "ERROR LOADING: " << e.what() << "\n";
    }
    return loaded_state;
}

// ----------------------------------------------------------------------
// MAIN DEMONSTRATION
// ----------------------------------------------------------------------

int main()
{
    std::cout << "--- 1. IN-MEMORY UNDO DEMO (SEMANTIC MOVE) ---\n";
    RestoreStack restore;

    SomeClass instance1{ {"Product A", 10, 20} };
    std::cout << "Initial: " << instance1 << "\n";

    // PUSH UNDO: Capture the current state by VALUE using the lambda's capture
    // This is the semantic move logic, guaranteeing constructor call on restore.
    restore.Push(
        [&instance1, state = instance1.GetRestorableState()]() noexcept
        {
            // The magic: use the saved state to call the parameterized constructor
            // and move-assign the temporary object back to the instance.
            instance1 = std::move(SomeClass{ state });
        });

    std::cout << "\nOperation: Set new values (30, 40)\n";
    instance1.set(30, 40);
    std::cout << "Current: " << instance1 << "\n";

    std::cout << "\nRestore: Pop() the undo command\n";
    restore.Pop();
    std::cout << "Restored: " << instance1 << "\n"; // State is back to {10, 20}

    // ----------------------------------------------------------------------

    std::cout << "\n--- 2. PERSISTENCE DEMO (BOOST SERIALIZATION) ---\n";

    // 2a. SAVE: Use Boost to serialize the current state to a file
    SaveState(instance1.GetRestorableState(), "smart_store_state.txt");

    // 2b. Simulate a program restart or new session
    // We create a new, temporary instance
    SomeClass new_instance{ {"(Uninitialized)", 0, 0} };
    std::cout << "\nNew Session/Instance (pre-load): " << new_instance << "\n";

    // 2c. LOAD: Use Boost to deserialize the state from the file
    SomeClass::RestorableState disk_state = LoadState("smart_store_state.txt");

    // 2d. RECONSTRUCTION: Use the loaded state to call the parameterized constructor
    // This is the hybrid part: Boost loads the data, but *our* constructor
    // provides the safety/invariants!
    new_instance = std::move(SomeClass{ disk_state });

    std::cout << "Loaded Instance (post-reconstruct): " << new_instance << "\n";

    return 0;
}

I'm a fresher, so please overlook any formatting or structural inconsistencies in this report.

[gem870]

@Moin2002-tech, We are all freshers, and that is why we keep learning to make a difference. Elon Musk today, despite his level and exploration, he never stopped learning. So you are highly welcome.

Based on both options, a team member has equally given such a suggestion, so I think we will go into it.