Re: ISO standards
Jeffrey Baker wrote:
It's not quite clear to me what it is you're trying to show here.
Sorry, I still think it's not clear.
It is mainly to learn vectors and become comfortable with its nature with
OOPs. To me it is still a new challenge and a litgitimate problem to solve.
I finally figured the best form of vector in relation to OOPs.
There are three types of arrays. The C style, the link list and the STL
form.
A linked list is not an array. A linked lists might be, probably
infrequently, implemented using arrays. They are not the same thing.
I suppose that technically, the "STL form", by which I suppose you mean
std::vector, is not an array either. Although I guess it's far more
reasonable to think of it as an array then it is to think of a linked
list as an array.
Which is better and where is one better used or is it just how the
programmer
feels?
I think that's almost purely subjective. Start with defining what you
mean by the word "better" and we'll have a better possibility of
answering the question. Generally, I tend to think of better as being
more communicative. But better can also mean, among other things,
faster, cheaper, or very importantly, correct.
bool operator()(const int &i1, const int &i2) const {
const int e1 = extractTensDigit(i1);
const int e2 = extractTensDigit(i2);
const bool result =
e1 < e2 ? true :
e2 < e1 ? false :
i1 < i2;
return result;
}
I don't know what you were try here. The STL std::sort does the task.
Why use this?
I don't recall seeing that you were limiting the values in the array you
called inum to 0 <= n < 100. The above code is meant to be able to sort
numbers that are > 100 too. You might end up with something like this:
1000, 1010, 1110, 21, 121, 145, 55, 55, 151, 156
Compare compare;
std::sort(inum.begin(), inum.end(), compare);
The'compare' here doesn't break down the intergers into ordered sets.
Take 'compare' out and you get sorted set of numbers.
See above.
I tend to think that using, even using std::cout; is not good. YMWV.
It preference. I like define them in the header file.
Please don't do that. Or perhaps you meant something else?
int inum[] =
{1,50,98,9,76,2,88,22,49,52,3,89,54,25,4,56,97,5,40,44,17,30,75,6,33,7,36,10,58,38,65};
It's not clear to me why inum isn't vector.
It can be. But you can think of this as a C string that gets sorted in a
vector. It can be a conversion.
I'm not clear on what you mean by that. How can I think of that as a C
string?
int i = 0;
while(inum[i] > 0)
Did you mean to tack a zero onto the end of inum above? Sorry, maybe
I'm having trouble following, but this looks like it might not terminate
correctly.
It terminated just fine like it would in a link list.while(current != 0)
while(inum[i] != 0) is the same and works too.
I think you got lucky. In the example you gave, there is no value in
inum that is equal to zero. (Or so I thought, maybe not, please see
below.) Therefore, I suspect that you are testing a location that is not
in the array inum.
If there was a zero value, then you're not using each value in inum.
Did you intend not to?
The one below shows better what its suppose to do with the 'friend' keyword.
I'm still not clear on what your objection is. I also think I may not be
clear on what task you want to accomplish. Perhaps you could clarify
both of these for me?
I am not objecting to it. I want to use STL, but I want to see where it is
best used.
The program I have below uses 'friend' to make it class worthy.
Now the program works with the 'friend ' keyword and without
How is this safe code? How is 'friend' protecting the code, like
member function keep code safe? Any simularity?
Is your question about the use of friend?
// sort by 10th place.cpp
#include <iostream>
using std::cout;
using std::endl;
using std::cin;
#include <vector>
using std::vector;
#include <algorithm>
using std::sort;
using std::copy;
using std::ostream_iterator;
class Tenth
{
void friend fx(int , vector<int>,vector<int>);
// take friend ou and leave the rest
// what would be the difference?
public:
// How strong is friend in OOPs?
};
Strong in what sense? Forgive my ignorance, but I have no idea why you
want to do this.
If you have a problem with friend, could you provide a specific question
and perhaps some illustrative code, please.
void fx(int inum[], vector<int>ij[])
{
Why make tmp here?
int tmp = 0;
for (int ii = 0; ii < 10; ii++)
{
31 is another magic number.
for(int i = 0; i < 31; i++)
{
if(inum[i]/10 == ii)
{
If you're only using tmp here, then why not
const int tmp = inum[i];
tmp = inum[i];
ij[ii].push_back(tmp);
It seems the only place you're using tmp is here, so why not just
ij[ii].push_back( inum[i] );
And you're sorting each time you go through the loop? Why?
sort(ij[ii].begin(), ij[ii].end());
Why is i being incremented here. I suspect this code doesn't do what
you want.
i++;
}
}
}// end for loop
for(int ii = 0; ii < 10;ii++)
{
copy(ij[ii].begin(), ij[ii].end(),ostream_iterator<int>(cout," "));
cout << endl;
}
}
int main()
{
Oh oops. Was that zero in inum in your previous example and did I miss
it before? If it was there, that would explain why the while loop in
your previous code example terminated. But I doubt if that's what you
wanted.
int inum[] =
{1,50,98,9,76,2,88,22,49,52,0,89,54,25,4,56,97,5,40,44,17,30,75,6,33,7,36,10,58,38,65};
vector<int> ij[10];
// each ij object can only hold 10 numbers per object.
I'm not quite sure what you mean by that. Each element of ij, each of
which is a std::vector<int>, is not limited in the number of elements it
can hold.
// So you have only 100 numbers from 0 to 99 to process here.
If that's the case, then your code should enforce that. And I'm not
quite sure what you mean by this either. Could inum contain duplicate
values? If not, then you might want to consider using std::set.
fx( inum,ij);
return 0;
}
This program is completely functional. The array can be changed to any set
of numbers from 0-99.
I doubt that. If you make inum 20 elements long, your code won't work
correctly because of that magic number 31 in your loop. I haven't taken
the time to look it up, but I suspect either something illegal or UB.
If you make inum 40 elements long the code probably won't do what you
expect, violating the principle of least astonishment. If you always
expect inum to be 31 elements then you ought to check for that.
I think that I am beginning to understand what you want to accomplish,
but I am certain that I do not understand your question related to OOP
and the stl. Please clarify.
LR
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]