By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
454,924 Members | 1,142 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 454,924 IT Pros & Developers. It's quick & easy.

WHy my program doesn't work

P: n/a
#include<iostream.h>
#include<stdlib.h>
void main(void)
{
unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
cout<<"Money summed = "<<(u);
}

thank you,
Duardo

Mar 24 '07 #1
Share this Question
Share on Google+
8 Replies


P: n/a
Duardo Mattheo wrote:
:: #include<iostream.h>
:: #include<stdlib.h>
:: void main(void)
:: {
:: unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
:: cout<<"Money summed = "<<(u);
:: }
::
:: thank you,
:: Duardo

Depending on the machine you have, 1 billion times some value is highly
likely to be larger than what an unsigned int can store.
Bo Persson
Mar 24 '07 #2

P: n/a
On Mar 24, 11:07 am, "Duardo Mattheo" <dudordoo123...@yahoo.dkwrote:
#include<iostream.h>
#include<stdlib.h>
void main(void)
{
unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
cout<<"Money summed = "<<(u);

}

thank you,
Duardo
Because you have to write

'std::cout' where you wrote 'cout'.

Because you can't write a number with spaces in it.

Because main has to return int.

So the next will work:
#include<iostream>
#include<stdlib.h>
int main(void)
{
unsigned int u=int(1000000000*rand()%RAND_MAX);
std::cout<<"Money summed = "<<(u);

return 0;
}

Mar 24 '07 #3

P: n/a
On Mar 24, 1:30 pm, "Colander" <colan...@gmail.comwrote:
On Mar 24, 11:07 am, "Duardo Mattheo" <dudordoo123...@yahoo.dkwrote:
#include<iostream.h>
#include<stdlib.h>
void main(void)
{
unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
cout<<"Money summed = "<<(u);
}
thank you,
Duardo

Because you have to write

'std::cout' where you wrote 'cout'.

Because you can't write a number with spaces in it.

Because main has to return int.

So the next will work:
#include<iostream>
#include<stdlib.h>
int main(void)
{
unsigned int u=int(1000000000*rand()%RAND_MAX);
std::cout<<"Money summed = "<<(u);

return 0;

}
(Replying to one selfs, what does the world do to me)

Now that we have the systax right, we can look at wat you are trying
to do.

I guess you want a random number between 0 or 1 and 1000000000.

This is not what the programme does....

Please lookup srand and rand in your manual.

srand is a function that will give you a new/different random number
each time you run your progrogramme.

Doing a modulo operation makes sure that a number is in a range, in
your case the range will be [0, RAND_MAX), and not [0, 1000000000).

Good luck

Mar 24 '07 #4

P: n/a
On 2007-03-24 14:02, Colander wrote:
On Mar 24, 1:30 pm, "Colander" <colan...@gmail.comwrote:
>On Mar 24, 11:07 am, "Duardo Mattheo" <dudordoo123...@yahoo.dkwrote:
#include<iostream.h>
#include<stdlib.h>
void main(void)
{
unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
cout<<"Money summed = "<<(u);
}
thank you,
Duardo

Because you have to write

'std::cout' where you wrote 'cout'.

Because you can't write a number with spaces in it.

Because main has to return int.

So the next will work:
#include<iostream>
#include<stdlib.h>
int main(void)
{
unsigned int u=int(1000000000*rand()%RAND_MAX);
std::cout<<"Money summed = "<<(u);

return 0;

}

(Replying to one selfs, what does the world do to me)

Now that we have the systax right, we can look at wat you are trying
to do.

I guess you want a random number between 0 or 1 and 1000000000.

This is not what the programme does....

Please lookup srand and rand in your manual.

srand is a function that will give you a new/different random number
each time you run your progrogramme.

Doing a modulo operation makes sure that a number is in a range, in
your case the range will be [0, RAND_MAX), and not [0, 1000000000).
And I'd like to point out that the range of the values output by rand
already is [0, RAND_MAX], after all that is what RAND_MAX means, the max
number that rand can output. So the modulo (%) operator is not needed.
Perhaps a / was intended so that the value will be between 0 and 1000000000?

Notice also that you need to seed rand before usage, or there's a great
chance that it will return the same value each time you run the
application, you can use the current time to get a quite good (but not
cryptographically secure) seed:

#include <iostream>
#include <cstdlib>
#include <ctime>

int main()
{
srand(time(0));
unsigned int nr = static_cast<unsigned int>(1000000000 *
rand() / double(RAND_MAX)
);
std::cout << nr;
return 0;
}

--
Erik Wikström
Mar 24 '07 #5

P: n/a
On 2007-03-24 12:09, Bo Persson wrote:
Duardo Mattheo wrote:
:: #include<iostream.h>
:: #include<stdlib.h>
:: void main(void)
:: {
:: unsigned int u=int(1 000 000 000*rand()%RAND_MAX);
:: cout<<"Money summed = "<<(u);
:: }
::
:: thank you,
:: Duardo

Depending on the machine you have, 1 billion times some value is highly
likely to be larger than what an unsigned int can store.
It will probably be enough on a modern 32-bit machine. What the OP
should watch out for is the fact that he/she is casting the result to
int but assigning to an unsigned int.

--
Erik Wikström
Mar 24 '07 #6

P: n/a
Dnia Sat, 24 Mar 2007 05:30:55 -0700, Colander napisa³(a):
#include<stdlib.h>
#include <cstdlib>
std::cout<<"Money summed = "<<(u);
Why 'u' in parenthesis?

--
SasQ
Mar 24 '07 #7

P: n/a
Erik Wikström wrote:
#include <iostream>
#include <cstdlib>
#include <ctime>

int main()
{
srand(time(0));
unsigned int nr = static_cast<unsigned int>(1000000000 *
rand() / double(RAND_MAX)
I don't think that will work. Assuming that the largest value is about
4Gib, you will overflow most of the data that rand() outputs when
multiplying it by 1000000000, loosing most of your resolution. The
following should work:

unsigned int nr = static_cast<unsigned int>(
(rand() * rand()) % 1000000000)

Assuming that RAND_MAX*RAND_MAX >= 1000000000-1 (in actual math, not on
a CPU's integer arithmetic set) this should work. And although (rand()
* rand()) could overflow, it wouldn't matter as that information is not
needed when trying to get a value in the range [0, 1000000000).
);
std::cout << nr;
return 0;
}
Adrian
--
__________________________________________________ ___________________
\/Adrian_Hawryluk BSc. - Specialties: UML, OOPD, Real-Time Systems\/
\ _---_ Q. What are you doing here? _---_ /
\ / | A. Just surf'n the net, teaching and | \ /
\__/___\___ learning, learning and teaching. You?_____/___\__/
\/______[blog:__http://adrians-musings.blogspot.com/]______\/
Mar 24 '07 #8

P: n/a
On 2007-03-24 18:02, Adrian Hawryluk wrote:
Erik Wikström wrote:
>#include <iostream>
#include <cstdlib>
#include <ctime>

int main()
{
srand(time(0));
unsigned int nr = static_cast<unsigned int>(1000000000 *
rand() / double(RAND_MAX)

I don't think that will work. Assuming that the largest value is about
4Gib, you will overflow most of the data that rand() outputs when
multiplying it by 1000000000, loosing most of your resolution. The
following should work:

unsigned int nr = static_cast<unsigned int>(
(rand() * rand()) % 1000000000)
I was more thinking along the lines of this (notice the added parentheses):
unsigned int nr = static_cast<unsigned int>(1000000000 *
(rand() / double(RAND_MAX))

It will not be able to produce all values in the range 0-1000000000, but
then again, with that range who would notice :-)

--
Erik Wikström
Mar 25 '07 #9

This discussion thread is closed

Replies have been disabled for this discussion.