Thread: Exam Question - Possible Mistake?

This may seem a pretty basic question but it has been bugging me
for the last couple of days. This question was on my end of year
C++ exam and was worth 4%. While I'm not too worried about
my grade, others in my class may be, and if the lecturer made a
mistake, it's policy that we get the marks for a correct answer if
we attempted it. Here goes:

Code:

class CoOrd
{
private:
    int m_nX;
    int m_nY;

public:
    CoOrd ();
    CoOrd (int nX, int nY);

    void someOp ();
};

Given the following global function,

Code:

void translate (int amount)
{
    m_nX += amount;
    m_nY += amount;
}

that adds a set value - amount - to the m_nX and m_nY member
variables of the CoOrd class defined above, what changes would
have to be made to the CoOrd class definition for this function to
work. You cannot change the translate function's implementation.

Thats the question, and the answer i guessed was to make
translate a friend of the class, thinking that it may be legal to
call the function off a class instance, but following the exam i
tried it out and it didn't work. The only alternative i can think
of would be to make translate a member of the class, but as the
question specifies, translate is global - wouldn't making it a
member in essence change its implementation?

Obviously translate cannot compile on its own as m_nX and m_nY
are undeclared locally, so is the question actually wrong or am I
really missing some other way of getting it to work? Thanks in
advance, I really appreciate any advice on this.

make m_nX and m_nY public static objects of the class.

[edit]that doesn't work either - at least with Dev-C++ compiler[/edit]

You can't make it a member becouse that would mean you must call it as a member like: myCoOrd.translate(5).

But then again, calling translate() by itself does not make sense without an object. Translate must somehow know which instance of CoOrd to change.

You could, in addition to making it a friend function, make m_nX and m_nY static, and create an instance of CoOrd inside translate(). That would not change the implementation of translate, but would make all CoOrd objects identical.

Originally Posted by Richie T

... so is the question actually wrong or am I
really missing some other way of getting it to work? Thanks in
advance, I really appreciate any advice on this.

Just get the answer from your lecturer and go from there.

Originally Posted by King Mir

You can't make it a member becouse that would mean you must call it as a member like: myCoOrd.translate(5).

But then again, calling translate() by itself does not make sense without an object. Translate must somehow know which instance of CoOrd to change.

You could, in addition to making it a friend function, make m_nX and m_nY static, and create an instance of CoOrd inside translate(). That would not change the implementation of translate, but would make all CoOrd objects identical.

initial code

Code:

{
    m_nX += amount;
    m_nY += amount;
}

your suggestion

Code:

{
    CoOrd t;
    t.m_nX += amount;
    t.m_nY += amount;
}

how does that not change the implementation? and why to you need to create a CoOrd object and make m_nX and m_nY static? that makes no sense.

RichieT, I have serious doubts about you lecturers level of C++ knowledge. First off, it does seem like a bad question. Second, anyone that still uses hungarian notation is EVIL!

It does not change The way translate is used when called. But I guess you're right, that's probably not what your professor ment. I'm confusig terms here.

Originally Posted by ChaosEngine

Second, anyone that still uses hungarian notation is EVIL!

But seriously, why?

>> First off, it does seem like a bad question. Second, anyone that still uses hungarian notation is EVIL!

Haha, I never liked it myself. And I agree, dodgy question alright. Seems like a lot of effort for identifying variables ... but I guess it was drilled into him somehow.

>> You cannot change the translate function's implementation
Does that mean you can't change the function heading to :

Code:

void CoOrd::translate( int amount )
{
    m_nX += amount;
    m_nY += amount;
}

? I mentioned a couple of the above recommendations in the exam, and what I mentioned here, but the question is:

Does changing the function's header/heading change the function's implementation?

>>RichieT, I have serious doubts about you lecturers level of C++
knowledge

Well perhaps serious is a bit extreme, he's made a few mistakes
like telling us that the following is illegal in C++ without a typedef:

Code:

struct thing
{
   int x, y, z;
};

int main (void)
{
    thing instance;
}

He's mixing up C with C++ there. He also uses void main, which
i don't like, but other than that it's been standard code

What it comes down to i suppose is the wording of the question:

>>Does changing the function's header/heading change the
function's implementation?

I think we might be able to argue that technically, making a
function a class member does change its implementation.

>>Just get the answer from your lecturer and go from there

Yes i think we will, i just wanted to see if there was a solution,
and it appears that there is none unless the word global is
removed from the question. I just wanted some ammunition
of sorts before i went further, since there are many programmers
here more experienced than me.

Thanks for for all the suggestions - legends as always

Here's your solution with translate untouched.
*Edit* a better solution without statics and using a global instance of the class.
**RE-Edit** now able to use any instance

Code:

#include <iostream>
using namespace std;
class CoOrd
{
    friend void translate(int x);
    friend int main();
private:
     int m_nX;
     int m_nY;

public:
    CoOrd ():m_nX(0),m_nY(0){};
    CoOrd (int nX, int nY);
    static CoOrd* gpCoOrd;

    void someOp ();
};
CoOrd* CoOrd::gpCoOrd = 0;

#define m_nX CoOrd::gpCoOrd->m_nX
#define m_nY CoOrd::gpCoOrd->m_nY


void translate (int amount)
{
    m_nX += amount;
    m_nY += amount;
}

#undef m_nX
#undef m_nY

int main()
{
    CoOrd anyInstance;
    anyInstance.gpCoOrd = &anyInstance;

    translate(10);


    cout << anyInstance.m_nX << endl;
    cout << anyInstance.m_nY << endl;
}

Interesting solution, but then that is an abuse of the preprocessor. Then it begs the question: hasnt the implementation of translate() been changed by the preprocessor?

Originally Posted by twomers

>> hasnt the implementation of translate() been changed by the preprocessor?

Circumstantially, yes it has, but emotionally, I don't think so. Interesting solution though!

Actually I think not, as the op stated, mn_X and mn_Y is undefined in translate, therefore must be defined outside of translate and that is all I am doing, giving them meaning.

The only other way I can maybe think of without preprocessor trick is to somehow make them references to static member. I tried that but could get quite get it right.