Don't allow empty object in vector

[Hashimatsu]

What can I do to prevent the user from just create an empty object?

This is an example:

class myClass
{
    public:
        
        string Foo;
        string Bar;

        void createObject()
        {
            cout << "Enter first string: " << endl;
            getline(cin, Foo);

            cout << "Enter second string: " << endl;
            getline(cin, Bar);

            return Foo, Bar;
        }
};

As it is now the user can press enter without typing anything and I do not want the user to be able to create objects without these values.

I fought about an if, something like if(Foo != "" || Bar != "") but I don't know where to put it, and what to return if the user has not made an input.

I would like it to loop back and let the user try again, but I need help with this...

Thanks in advance

[vlad from moscow]

Try the following code

#include <string>
#include <iostream>

class myClass
{
    private:
        myClass( const std::string &Foo, const std::string &Bar ) : Foo( Foo ), Bar( Bar ) {}
        std::string Foo;
        std::string Bar;

    public:
        static myClass createObject()
        {
            std::string Foo;

            do
            {
                std::cout << "Enter first non-empty string: " << std::endl;
                std::getline( std::cin, Foo );
            } while ( Foo.empty() );

            std::string Bar;

            do
            {
                std::cout << "Enter second non-empty string: " << std::endl;
                std::getline( std::cin, Bar );
            } while ( Bar.empty() );

            return ( myClass( Foo, Bar ) );
        }
};


int main()
{
    myClass m1 = myClass::createObject();

   return 0;
}

[TheIdeasMan]

Try making the return value for createObject bool, that way you can return false if the input was empty.

Make the createObject take a references or a pointers to Foo and Bar - that way you can set their values in the function and not have to return them.

returning some thing for a void function as you have it now is an error, and you can only return one variable.

Edit:

Also don't have any public variables in a class, make them private or protected and provide functions to access them.

HTH

[JLBorges]

Ensuring that the invariant for an object is established should ideally be done in a constructor. (Creating an object with data entered by the user is only one of many different possible ways for crating an object).

The classical way for the constructor to report an error is by throwing an exception. With that, any user of the class can create objects in a way that is most appropriate for that user's particular use case, without violating its encapsulation.

Something like:

struct A
{
    A( const std::string& s ) : str(s)
    {
        if( str.empty() || !std::isdigit(str[0]) )
            throw std::domain_error( "the string does not start with a digit" ) ;
    }

    // ...

    private:
       std::string str ; // invariant: str is not empty and must start with a digit
};

And then:

A make_a_from_user_input()
{
    std::string s ;
    std::getline( std::cin, s ) ;

    try { return A(s) ; }
    catch( const std::exception& e )
    { std::cerr << "error in input: " << e.what() << ". try again\n" ; }

    return make_a_from_user_input() ;
}