"Prawit Chaivong" <pr******@gmail .com> wrote in message
news:11******** **************@ z14g2000cwz.goo glegroups.com.. .
Peter Julian wrote: "Prawit Chaivong" <pr******@gmail .com> wrote in message
news:11******** **************@ g47g2000cwa.goo glegroups.com.. .
<snip>
This is an example.
------------------------------------
std::set<MyClas s> g_set;
void getBegin(MyClas s **s)
{
std::set<MyClas s>::iterator itr;
itr = g_set.begin();
*s = &(*itr); // is '*itr' temporary?
}
-------------------------------------
You are way too short on information and your knowledge on references, set
containers + iterators is rather lacking. This is making helping you very,
very difficult.
An iterator's type should always be type defined, since each STL container
supports predefined iterator types. The question you are asking refers to
*itr and whether its a temporary. When written correctly, and by using a
reference to the std::set container as a parameter to the function, *itr
returns the object thats first in the set's order of elements.
MyClass getBegin(set<My Class>& ref_set)
{
typedef std::set<MyClas s>::iterator SITER;
SITER it = ref_set.begin() ;
return *it;
}
A std::set container relys on a predicate
(
http://en.wikipedia.org/wiki/Predicate).
When you insert an object into such a container, that container needs to
compare the insertable element to the elements already in the set. The
following will fail unless you supply an appropriate less_than operator
function to compare MyClass-type objects.
MyClass a;
MyClass b;
MyClass smallest = a < b ? a : b; // returns the lesser of the 2
By default, the std::set uses less<> to insert elements in the ordered
container. This means your MyClass class needs to have access to an
operator< for the std::set container to be able to order the elements when
inserting. Usually, the operator< is not a member of the class:
bool operator<(const MyClass& left, const MyClass& right)
{
....
}
In the case you wish to compare MyClass's private members to each other, you
need to make that operator a friend of the class.
#include <iostream>
#include <set>
class MyClass
{
int m_n;
public:
MyClass(int n) : m_n(n) { }
~MyClass() { }
int getN() { return m_n; }
// friendify op< to allow access to private members
friend bool operator<(const MyClass& left, const MyClass& right);
};
// global operator< to compare MyClass-type objects
bool operator<(const MyClass& left, const MyClass& right)
{
return left.m_n < right.m_n;
}
MyClass getBegin(std::s et<MyClass>& ref_set)
{
typedef std::set<MyClas s>::iterator SITER;
SITER it = ref_set.begin() ;
return *it;
}
int main()
{
std::set<MyClas s> myset;
for (size_t i = 1; i < 10; ++i)
{
myset.insert(i) ; // automatically ordered
}
// using a non-member function:
MyClass first = getBegin(myset) ;
std::cout << "[using getBegin()]\tfirst element's value in set = ";
std::cout << first.getN();
// alternative to using a non-member function
typedef std::set<MyClas s>::iterator SITER;
SITER it = myset.begin();
std::cout << "\n[using iterator]\tfirst element's value in set = ";
std::cout << (*it).getN();
return 0;
}
/* output:
[using getBegin()] first element in set = 1
[using iterator] first element in set = 1
*/
