Thread: c++ primer exercise 15.31

Hi,
to readers of C++ primer 5th edition. I wrote two answers for the exercise 15.31 supposing (a) answer corrects which out of the two following scenario is correct?

Code:

/*Exercise 15.31: Given that s1, s2, s3, and s4 are all strings, determine
 * what objects are created in the following expressions:
 *  
 *   (a) Query(s1) | Query(s2) & ~ Query(s3);
 *   (b) Query(s1) | (Query(s2) & ~ Query(s3));
 *   (c) (Query(s1) & (Query(s2)) | (Query(s3) & Query(s4)));
 *
 * a) AndQuery --- OrQuery --- WordQuery(s1)
 *       |            |
 *       |             --- WordQuery(s2)
 *       |
 *        --- NotQuery --- WordQuery(s3)
 *
 * b1) The same of (a)
 *
 * b2) OrQuery --- AndQuery --- WordQuery(s2)
 *       |           |
 *       |            --- NotQuery --- WordQuery(s3)
 *       |
 *        --- WordQuery(s1)
 *
 * c1) OrQuery --- AndQuery --- WordQuery(s4)
 *       |           |
 *       |            --- WordQuery(s3)
 *       |
 *        --- AndQuery --- WordQuery(s2)
 *               |
 *                --- WordQuery(s1)
 *
 * c2) AndQuery --- WordQuery(s4)
 *       |
 *        --- OrQuery --- WordQuery(s3)
 *               |
 *                --- OrQuery --- WordQuery(s2)
 *                       |
 *                        --- WordQuery(s1)
 */

(b1) and (c2) answers or (b2) and (c1) answers?
Be careful to the parenthesis when you evaluate (c) expression, it's deceiving.
Thanks in advance

Originally Posted by Salem

Operator precedence determines how terms are combined, but the evaluation of each term is only loosely connected to precedence.

Those operator ( & | ~ ) are overloaded operator defined in the interface class Query. Does operator precedence apply also to overloaded operators or are they plain right-associative?
This matters it's discussed in §15.9.1 and beyond of the book, however once builds those objects are interrelated between them in a hierarchy, the exercise asked for the hierarchy that rispect class inheritance. It must be that way otherwise dynamic binding won't work.
Which answers are correct? Thought a) b1) c2)...
Thanks again

Originally Posted by laserlight

where do these AndQuery, OrQuery, WordQuery come from?

First of all thanks @Salem, I didn't know what the compiler does behind the scenes.
@Laserlight: those classes are part of the design of the back-end of the whole program, sorry the book is DRM copyright protected so I can't post the code wrote by the authors however I thought that it isn't nothing wrong discussing about answers of the book's exercises so if somebody has it he can share with me its answers.

After a bit of investigation I was able to write code that using dynamic binding it nicely surrounds with parenthesis the operands of a given expression.
Now it's easy test the expressions of the exercise and answer to it.

Code:

#include <iostream>
#include <memory>

using namespace std;

class Backend
{
friend    class Frontend;
protected:
    ~Backend() = default;
private:
    virtual string get_expr() const = 0;
};

class Frontend
{
friend    Frontend operator~(const Frontend&);
friend    Frontend operator|(const Frontend&, const Frontend&);
friend    Frontend operator&(const Frontend&, const Frontend&);
public:
    Frontend(const string&);
    string get_expr() const    {return f ->get_expr(); }
private:
    Frontend(shared_ptr<Backend> b): f(b) { }
    shared_ptr<Backend> f;
};

class Operand: public Backend
{
friend    class Frontend;
protected:
    Operand(const string& s): word(s) { }
    string get_expr() const    {return word;}
private:
    string word;
};
inline Frontend::Frontend(const string& s): f(new Operand(s)) { }

class NotExpr: public Backend
{
friend    Frontend operator~(const Frontend&);
protected:
    NotExpr(const Frontend& f): front(f) { }
    string get_expr() const    {return "~(" + front.get_expr() + ")"; }
private:
    Frontend front;
};

class OrExpr: public Backend
{
friend    Frontend operator|(const Frontend&, const Frontend&);
protected:
    OrExpr(const Frontend& l, const Frontend& r, string s): lOp(l), rOp(r), symbol(s) { }
    string get_expr() const    {return "(" + lOp.get_expr() + " " + symbol + " " + rOp.get_expr() + ")"; }
private:
    Frontend lOp, rOp;
    string symbol;
};

class AndExpr: public Backend
{
friend    Frontend operator&(const Frontend&, const Frontend&);
protected:
    AndExpr(const Frontend& l, const Frontend& r, string s): lOp(l), rOp(r), symbol(s) { }
    string get_expr() const    {return "(" + lOp.get_expr() + " " + symbol + " " + rOp.get_expr() + ")"; }
private:
    Frontend lOp, rOp;
    string symbol;
};

Frontend operator~(const Frontend& f)
{
    return shared_ptr<Backend>(new NotExpr(f));
}
Frontend operator|(const Frontend& l, const Frontend& r)
{
    return shared_ptr<Backend>(new OrExpr(l, r, "|"));
}
Frontend operator&(const Frontend& l, const Frontend& r)
{
    return shared_ptr<Backend>(new AndExpr(l, r, "&"));
}
ostream& operator<<(ostream& os, const Frontend& f)
{
    os << f.get_expr() << flush;
    return os;
}

int main()
{
    using Query = Frontend;

    Query q=Query("s1") | Query("s2") & ~ Query("s3");
    cout << q << endl;    // prints: (s1 | (s2 & ~(s3)))

    q=Query("s1") | (Query("s2") & ~ Query("s3"));
    cout << q << endl;    // prints: (s1 | (s2 & ~(s3)))

    q=(Query("s1") & (Query("s2")) | (Query("s3") & Query("s4")));
    cout << q << endl;    // prints: ((s1 & s2) | (s3 & s4))

    return EXIT_SUCCESS;
}

The correct answers are:

Code:

/* Exercise 15.31: Given that s1, s2, s3, and s4 are all strings, determine
 * what objects are created in the following expressions:
 *  
 *   (a) Query(s1) | Query(s2) & ~ Query(s3);
 *   (b) Query(s1) | (Query(s2) & ~ Query(s3));
 *   (c) (Query(s1) & (Query(s2)) | (Query(s3) & Query(s4)));
 *
 * a) OrQuery --- AndQuery --- NotQuery --- WordQuery(s3)
 *       |            |
 *       |             --- WordQuery(s2)
 *       |
 *        --- WordQuery(s1)
 *
 * b) The same of a)
 *
 * c) OrQuery --- AndQuery --- WordQuery(s4)
 *       |           |
 *       |            --- WordQuery(s3)
 *       |
 *        --- AndQuery --- WordQuery(s2)
 *               |
 *                --- WordQuery(s1)
 */

HTH

Originally Posted by Elysia

Did you try it on different compilers?

No I didn't. This is the compiler:

Code:

$ g++ --version
g++ (Debian 4.9.2-10) 4.9.2

Since new statement was used I checked it for memory leak, all ok.