Printable View
I have a data structure that looks like this.
I was wondering how I could sort the vector<Election::Candidate*>* myCandidates by their total votes. How would I go about doing this.Code:struct Election{
struct Candidate{
vector<int*>* myPrecincts;
string* myName;
int* myTotalNumberOfVotes;
};
vector<Election::Candidate*>* myCandidates;
string* myName;
int* myTotalNumberOfVotes;
};
vector<Election*>* myElections;
You use std::sort.
Notice that std::sort requires you to define operator< on your struct Candidate, or maybe struct Candidate *.
Did you sprinkle asterisks in your code at random, or do you not intend to actually have any vectors in your code, only pointers to vectors?
It's a project for school I just wanted to get used to pointers. I'm new to c++ learned java last year. I just made everything a pointer so I could work with them. How would I do what you said.
If you can't type std::sort into the little box at the top-right of your browser, I'm not sure how much help I can be.
Have you ever overloaded an operator before?
Getting used to pointers is a very good idea. However, you should do so on a project where using pointers will not actually prevent you from actually doing anything. (Hint: this is a project where using pointers will actually prevent you from actually doing anything.)
This is what I have so far what am I doing wrong.
for this data structCode:std::sort(myElections->at(i)->myCandidates->begin(), myElections->at(i)->myCandidates->end(), Election::Candidate::operator ());
Code:struct Election{
struct Candidate{
vector<int*>* myPrecincts;
string* myName;
int* myTotalNumberOfVotes;
bool operator () (const Election::Candidate& lhs , const Election::Candidate& rhs){
return lhs.myTotalNumberOfVotes < rhs.myTotalNumberOfVotes;
}
};
vector<Election::Candidate*>* myCandidates;
myCandidates is a vector of pointers-to-Candidate, not Candidates themselves.
Actually, that's not true; myCandidates is a pointer to a vector of pointers-to-Candidate. One might hope that it actually points to something worthwhile, but I'm not holding my breath.
Let me just say this: every asterisk you have in that code is wrong. Take them all out.
They aren't wrong and I know how to use them, and they do point to something. I'm not an idiot. I just wanted to know how to sort the vector in c++. Could you show me an example. you don't have to use my code. I'm more than capable of making them pointers from an example some shows me.
If you insist on pointers, then
Remember, lhs isn't a real candidate, and myTotalNumberofVotes isn't a real number.Code:bool operator () (const Election::Candidate*& lhs , const Election::Candidate*& rhs){
return *(lhs->myTotalNumberOfVotes) < *(rhs->myTotalNumberOfVotes);
}
ok thanks I forgot to add the pointers to that. I probably should take a break from the homework. How do I do the sort part. This is what I have.
Code:std::sort(myElections->at(i)->myCandidates->begin(), myElections->at(i)->myCandidates->end(), Election::Candidate::operator ());
The operator() is more-or-less implied, so you would need to pass in something of type Election::Candidate.Quote:
Originally Posted by Zosden
I think that did the trick. Thanks man. Sorry for being short with you I'm just used to people who say something like you did in the beginning and then offer no help cause I'm not doing it their way. I'll post if I have any more questions.
I won't say that I think you've made very good choices, but I have no problem helping you be a fool if that's what you really want. :) Good luck.
This is for a class, in which I'm suppose to learn c++. I'm trying to do that I understand nobody would use pointers like this. I used them like this in order to get use to using pointers. By the way I don't think it is sorting the vector. Here's the line that I have that's suppose to sort it.
Code:std::sort(myElections->at(i)->myCandidates->begin(), myElections->at(i)->myCandidates->end());
If you don't use a third parameter, it will assume operator<, which you didn't define. You would need something like
If you have something of that type handy, put it in, otherwise you'll have to do something scary likeCode:std::sort(myElections->at(i)->myCandidates->begin(), myElections->at(i)->myCandidates->end(), /*some object of type Election::Candidate goes here */);
One * to dereference the iterator back to a Candidate *, since that's what the vector holds, and one * to dereference that into an actual Candidate.Code:*(*(myElections->at(i)->myCandidates->begin()))
Where would I put that in. It won't compile when I do this.
Code:std::sort(*(*myElections->at(i)->myCandidates->begin()), *(*myElections->at(i)->myCandidates->end()));
It goes where the /*goes here comment*/ was before; you need the begin, you need the end, and then you need something that, if you put () after it compares the things.
Would something like this work.
Code:std::sort(myElections->at(i)->myCandidates->begin(), myElections->at(i)->myCandidates->end(), Election::Candidate::operator ());
Didn't we start here? The third parameter needs to be a function object. I.e., it needs to be something that has an operator(), not an operator() itself. I.e., it needs to be an object of type Election::Candidate, so that when operator () is applied to it, the Election::Candidate::operator() you defined comes out.
(I mean, maybe operator() will work if it can accept a function pointer in the third spot in place of a function object, but I've never tried.)
What would I place in the third parameter exactly or what pointer could I get rid of to make it easier.
If it were me, I would have called my sorting function
made it a free function (i.e., not in a class), made it a friend if necessary, and not used the third parameter to sort at all.Code:bool operator<(const Election::Candidate*& lhs , const Election::Candidate*& rhs)
If for some reason I'm not allowed to overload that operator, I'd make it its own object:
and just used Bob for the third parameter.Code:class Bob {
operator () {const Election::Candidate*& lhs , const Election::Candidate*& rhs) //etc
}
Where would I overload the operator< at. Outside or inside the class, and If so how does it know to use that operator overload.
It knows because that's what it will try as a default. If you have a vector container of some type (foo for example) and call the default version of the sort function the compiler will try to use/find the operator< that works with foo objects. If it can't find one then the compiler will complain and you'll get a compiler error.
As mentioned, you can create a free function version of operator< (not inside the class) that should take two const references to your object type and does a comparison of those two objects returning a true/false boolean value. Then you'd just call the default version of sort and the compiler should take care of things for you at compile time.
The compiler gives me this final error
'operator <' must have at least one formal parameter of class typeCode:bool operator<(const View::Election::Candidate*& lhs , const View::Election::Candidate*& rhs){
return *lhs->myTotalNumberOfVotes < *rhs->myTotalNumberOfVotes;
}
I was afraid of that. (Reason 347 not to use pointers -- you can't overload.) Then you'll have to go with curtain 2 and a function object.
which pointer messes it up. I can change it.
The vector-of that we're trying to sort. Since we're trying to sort pointers, the compiler gives us a frowny face, because pointers are built-in types. If we were trying to sort Election::Candidates themselves, we could define operator<.
Those are the only pointers that I have to have for the assignment. Would having the class that just has the operator< work with the pointers.
Then you'll have to go with class Bob and the function object.
Is that what I would have to do.Code:#ifndef COMPARATOR_H
#define COMPARATOR_H
#include "View.h"
class Comparator{
bool operator () (const View::Election::Candidate*& lhs , const View::Election::Candidate*& rhs){
return *lhs->myTotalNumberOfVotes < *rhs->myTotalNumberOfVotes;
}
};
#endif
Does your assignment require you to use a billion pointers? If not, I think your time would be better spent doing it properly without all the pointers, rather than trying to fit a square peg into a round hole...
Actually, I beg to differ. Learning to do something completely wrong is probably worse than not learning it at all. Continuing along that path would make you an idiot in most people's books. It's also entirely likely that all the problems your having are because of how you've wrongly misused pointers.Quote:
Originally Posted by Zosden
Can you even show that everything is allocated correctly, and that everything is deleted correctly afterwards, because I seriously doubt it!
So, no I wont help you shoot yourself in your foot, or give you enough rope to hang yourself!
Yes I know everything works. I'm not a brand new to programming, and I've tested my code thoroughly. I just wanted to know how to sort a vector of pointers. The assignment is to have a vector of pointers. I just made everything a pointer to learn how to use them. for hopefully the last time, I know I made it harder than I needed to I just wanted to learn how to use them.
Then get rid of all the other pointers and just use a vector of pointersQuote:
Originally Posted by Zosden
vector<int*> instead of vector<int*>*
vector<Election::Candidate*> instead of vector<Election::Candidate*>*
Then you'll still be using pointers, but you'll be using them in a more sane way.
That still doesn't fix my original problem.
What happens when you pass your Comparator class to std::sort()?Quote:
Originally Posted by Zosden
BTW, I wouldn't bother passing the pointers by reference:
Since you're not planning on modifying the actual pointers themselves and you won't gain any performance benefit on a 4 or 8 byte pointer. They'll just cause more confusion than anything else.Code:bool operator () (const View::Election::Candidate*& lhs , const View::Election::Candidate*& rhs){
what would I pass a new Comparator
So that comparator looks right to me, without testing it. You would just give a Comparator object as the third parameter to std::sort.
Code:Comparator who_wins;
std::sort(whatever.begin(), whatever.end(), who_wins);
I believe you'd want to do something like this:Quote:
Originally Posted by Zosden
Code:std::sort( myElections->at(i)->myCandidates->begin(),
myElections->at(i)->myCandidates->end(),
Comparator() );
These lines are for the line bool operator is onCode:#ifndef COMPARATOR_H
#define COMPARATOR_H
#include "View.h"
class Comparator{
bool operator <(const View::Election::Candidate *& lhs, const View::Election::Candidate *& rhs){
return *lhs->myTotalNumberOfVotes < *rhs->myTotalNumberOfVotes;
}
};
#endif
error C2653: 'View' : is not a class or namespace name
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int
error C2143: syntax error : missing ',' before '*'
These lines are for the next line
error C2065: 'lhs' : undeclared identifier
error C2227: left of '->myTotalNumberOfVotes' must point to class/struct/union/generic type
Ditch the invalid dereferencing.Quote:
Originally Posted by Zosden
1. Well, where did View come from? You never had it before.
2. The parentheses in my example were not superfluous; right now you are dereferencing lhs, but you need to dereference lhs->myTotalNumberofVotes.
You stated earlier that your goal in all this was to learn to use pointers. Then for heaven's sake, learn to use pointers for something that they were actually meant to be used for.
If you were given a screw driver to learn how to use, you wouldn't learn how to use it by trying to hammer nails in with it.
If you want to learn how to use pointers, then try writing your own linked list or doubly-linked list. That's a good way to learn all about pointer manipulation.
If you goal is instead actually to write good code, as you would if you were employed as a developer, then you need to drop the unnecessary pointers from the code you're using.