Prototype in C++ - c++

Question

Would the answer just be C and E? I am confused as to if bool &status can be passed by reference?
You want a function that reads in data about a movie from a specified file and returns a Movie object, either via a return value or via a parameter. It should also return some indication of success or failure either via a return value or via a parameter. Which of the following would be possible prototype choices for the above requirements? Select all that apply.
A. Movie readMovie(string filename);
B. bool readMovie(string filename, Movie m);
C. Movie readMovie(string filename, bool &status);
D. bool readMovie(string filename, const Movie &m);
E. bool readMovie(string filename, Movie &m);
F. Movie readMovie(string filename, bool status);

Answer 1

All of them can work:
A. if Movie itself can have a well known bad value (equivalent to end, EOF or NULL), or a member to check whether it's in a good state, this is fine:
Movie readMovie(string filename);
Movie m = readMovie(filename);
if (m.good() || m != Movie::InvalidMovie || ... ) {
however, I suspect the questioner thinks this doesn't count as indicating success via a return value ...
B. if Movie is typedef'd to a pointer, or a shared_ptr, or if Movie is a lightweight wrapper for a refcounted MovieImpl object (for example), this is fine (because the caller's shared state is mutated via readMovie's copy of the wrapper)
bool readMovie(string filename, Movie m);
however, I suspect the questioner thinks this doesn't count as indicating success via a ... parameter. (NB. A's Movie could also be a typedef, smart pointer or other handle-body style thing).
C. this is definitely fine (and even the questioner knows it)
Movie readMovie(string filename, bool &status);
D. same constraints as B
bool readMovie(string filename, const Movie &m);
E. fine
bool readMovie(string filename, Movie &m);
F. stupid: this can work in the same was as A, but the status param is useless and misleading. So, I'm certain the questioner doesn't expect this to work:
Movie readMovie(string filename, bool status);
So, what can really be made to work: all of them.
What the questioner probably wants to hear: C, E.
What you should be looking at:
designing clear, expressive, efficient interfaces that are easy to use correctly (none of the above fit this, IMO)
appropriate use of exceptions instead of return codes (if failure is genuinely exceptional)
passing that string filename by const reference
getting a better teacher.

Answer 2

Let's see:
A provides no boolean indication of success. False.
B is passing Movie by value, so there's no way it will get returned. False.
C returns a movie, and the bool is passed by ref so it will get modified. True.
(skip)
E is the opposite of C, so it will work too. True.
(back to) D is the same as E, except it will be a const Movie this may or may not be appropriate. True?
F is the opposite of B, and fails for the same reason. False.
It's not a terribly clear question, and I would indicate my reasoning for my answers on the test/homework.

Answer 3

A movie is a big thing, so it should be allocated dynamically.
Therefore, use a smart pointer.
The code below demonstrates/proves how each and every proposed function signature supports returning a loaded movie and checking whether it succeeded or failed, with the most natural interpretation of the information provided (in particular, that a "movie" is a movie).
Note that the signatures in the question are all examples of Very Bad Design™.
The signature shown in namespace right in the code below is however OK:
It supports Windows filenames in general.
It ensures that if the load fails, the calling code has no movie object to (erroneously) play with, and this is done by throwing an exception to indicate failure.
It passes the string by reference to const (for efficiency and as a general good habit).
#include <memory> // std::shared_ptr
#include <new> // std::nothrow
#include <stdexcept> // std::runtime_error
#include <string> // std::string
class MovieData
{
// Whatever
};
// *** A movie is a big thing, so it should be allocated dynamically. ***
// *** Therefore, use a smart pointer. ***
//
typedef std::shared_ptr< MovieData > Movie;
namespace a {
using std::string;
using std::nothrow;
Movie readMovie(string filename)
{
return 0?0
: filename == "succeed"? Movie( ::new(nothrow) MovieData )
: Movie();
}
bool test( string const& filepath )
{
Movie const m = readMovie( filepath );
return (m != nullptr);
}
}
namespace b {
using std::string;
using std::nothrow;
bool readMovie(string filename, Movie m)
{
if( filename != "succeed" || m == nullptr )
{
return false;
}
*m = MovieData();
return true;
}
bool test( string const& filepath )
{
Movie const m( ::new(nothrow) MovieData );
return readMovie( filepath, m );
}
}
namespace c {
using std::string;
using std::nothrow;
Movie readMovie(string filename, bool &status)
{
status = false;
if( filename != "succeed" )
{
return Movie();
}
Movie const result( ::new(nothrow) MovieData );
status = true;
return result;
}
bool test( string const& filepath )
{
bool result = false;
readMovie( filepath, result );
return result;
}
}
namespace d {
using std::string;
using std::nothrow;
bool readMovie(string filename, const Movie &m)
{
if( filename != "succeed" || m == nullptr )
{
return false;
}
*m = MovieData();
return true;
}
bool test( string const& filepath )
{
Movie const m( ::new(nothrow) MovieData );
return readMovie( filepath, m );
}
}
namespace e {
using std::string;
using std::nothrow;
bool readMovie(string filename, Movie &m)
{
if( filename != "succeed" )
{
return false;
}
m.reset( ::new(nothrow) MovieData );
return (m != nullptr);
}
bool test( string const& filepath )
{
Movie m;
return readMovie( filepath, m );
}
}
namespace f {
using std::string;
using std::nothrow;
Movie readMovie(string filename, bool status)
{
(void) status; struct status; // Intentionally not used.
if( filename != "succeed" )
{
return Movie();
}
return Movie( ::new(nothrow) MovieData );
}
bool test( string const& filepath )
{
return (readMovie( filepath, bool() ) != nullptr);
}
}
namespace right {
using std::wstring; // Using wide string supports nearly all Windows filenames.
using std::runtime_error;
Movie readMovie( wstring const& filepath )
{
if( filepath != L"succeed" )
{
throw std::runtime_error( "right::readMovie: failed because ..." );
}
return Movie( new MovieData );
}
bool test( wstring const& filepath )
{
try
{
readMovie( filepath );
return true;
}
catch( ... )
{
return false;
}
}
}
#define TEST( name, filename ) \
wcout << #name "::readMovie" << "( " << #filename << " ) " \
<< (name ::test( filename )? "succeeded" : "failed") << "." << endl;
#include <iostream> // std::wcout, std::endl
int main()
{
using std::wcout; using std::endl; using std::boolalpha;
wcout << boolalpha;
TEST( a, "succeed" );
TEST( a, "fail" );
wcout << endl;
TEST( b, "succeed" );
TEST( b, "fail" );
wcout << endl;
TEST( c, "succeed" );
TEST( c, "fail" );
wcout << endl;
TEST( d, "succeed" );
TEST( d, "fail" );
wcout << endl;
TEST( e, "succeed" );
TEST( e, "fail" );
wcout << endl;
TEST( f, "succeed" );
TEST( f, "fail" );
wcout << endl;
TEST( right, L"succeed" );
TEST( right, L"fail" );
}
Output (test results):
a::readMovie( "succeed" ) succeeded.
a::readMovie( "fail" ) failed.
b::readMovie( "succeed" ) succeeded.
b::readMovie( "fail" ) failed.
c::readMovie( "succeed" ) succeeded.
c::readMovie( "fail" ) failed.
d::readMovie( "succeed" ) succeeded.
d::readMovie( "fail" ) failed.
e::readMovie( "succeed" ) succeeded.
e::readMovie( "fail" ) failed.
f::readMovie( "succeed" ) succeeded.
f::readMovie( "fail" ) failed.
right::readMovie( L"succeed" ) succeeded.
right::readMovie( L"fail" ) failed.