Re: Accelerated C++ exercise 9.2
utab wrote:
On Tue, 20 May 2008 10:13:46 -0400, Victor Bazarov wrote:
utab wrote:
On Mon, 19 May 2008 22:11:35 -0400, Victor Bazarov wrote:
utab wrote:
Dear all,
In a question in the highly recommended book Accelerated C++, it is
asked to change a const function into a plain function. After on the
reader is expected to find which function(s) should change.
The function to change is
original version
std::string name() const { return n; }
And this function is called from a predicate function which is passed
to a sort for vector:
original version
bool compare( const Student_info& x, const Student_info& y)
{
return x.name() < y.name();
}
and somewhere in the code sort is called for vector
sort(vec.begin(),vec.end(),compare)
Turning the name into a plain non-const function requires the change
of the const parameters of the compare function because const objects
can call const member functions. But making this change does not
solve my problem. I am getting an error(which is not that helpful
from g++) from the sort function and compare predicate. If someone
wants the whole code(might be a bit long though), I can paste it but
I wanted to ask it directly from the above explanation.
Can somebody help me to figure this problem out?
Here is what you have
struct foo {
int bar() const;
};
Here is what the exercise expects you to implement instead:
int bar(foo const&);
A member function takes a hidden argument - the object for which it
is called (you can either think it's a pointer or a reference, it
doesn't matter, really). A non-member function has to have an open
argument (there is nothing hidden in it).
V
Thanks for the answer, I tested something simple with this code
#include <cstdlib>
#include <iostream>
#include <list>
#include <sstream>
#include <map>
using namespace std;
struct foo{
foo():a(0){}
foo(int A):a(A) {}
//int bar() const {return a;};
int bar() {return a;};
private:
int a;
};
//void test_function(const foo &f)
void test_function(foo &f)
{
cout << f.bar() << endl;
}
int main()
{
foo fobj(5);
test_function(fobj);
return 0;
}
I commented out the const function and replaced that with a non-const
function. It works as intended but I am still not clear what is the
difference for my original problem. That is conceptually the same(or at
least that is what I think). I am trying to call a non-const member
function from inside a non-member function.
Why? What is the relevance to the problem at hand? Your 'compare'
function has two arguments, passed by a reference, both const.
I think I am a hard learner, or my english is getting worser ;)
Ok let me go slowly: if I change the name to a normal function. The const
references of the stand alone function can not call this function, right?
I don't understand this statement. You have a stand-alone function
'compare'. You have a member function 'name'. If you change 'name' to
be a stand-alone function, why couldn't 'compare' call it? You will, of
course, have to change the code of 'compare' to call the new 'name'
because the syntax of calling a standalone function and a member
function is different.
To call a member 'bar' with a 'foo' object, I write
fooObject.bar();
To call a standalone 'bar' with a 'foo' object I write
bar(fooObject);
This is the problem to tackle.
Really?
And when calling the stand alone function, the normal object is converted
to a const by the compiler(I am assuming that the parameters are still
const &), but this signature is not appropriate to call a normal function,
right?
Again, I don't understand what you're trying to confirm here. If the
argument of the standalone function is a reference to const, the object
will be converted (or even a temporary may be created) and then the
reference argument will be bound to that object. Not sure how
"appropriate" plays here.
If the second reasoning is right, then changing a const function should
also enforce the update of the const& parameters to normal references. This
was my idea on relevance to the struct example.
Or am I still dicussing sth different?
Your 'name' member function is 'const'. If you convert it to a
standalone function, you should probably preserve the limitations
imposed by the "const-ness" of the object, IOW make the argument of the
standalone function 'const' as well. That's a design decision, but it
is an important one. If you don't, if you make the standalone function
to require the object to be non-const, then you won't be able to call
that function from a context where the object is 'const' without a
const_cast (which I actually do not recommend).
Am I being unclear? Please point out what is unclear in my explanation
and I will try to rephrase.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask