I want to generate a random number for the temperature. The code I used is below:
int Temp()
{
// genreate random temperture
// initialize random seed:
srand ( time (NULL) );
// generate number between 1 and 100:
int t = rand() % 100 + 1;
std::cout << t << std::endl;
return t;
}
When the program is run, instead of displaying a number between 1 and 100, it display the following:
010C1109
Could someone explain where or why it is going wrong?
Edit: If anyone wondering I used the following:
#include <iostream>
#include <string>
#include <fstream>
#include <istream>
#include <ctime>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <map>
#include <cstdlib>
#include <cstring>
#pragma once
How to choose the way your numbers are displayed:
std::cout << std::hex << t << std::endl; //displays in hexadecimal
std::cout << std::dec << t << std::endl; //displays in decimal
In my example I see
58 in hexadecimal and 88 in decimal (5*16+8).
Here are official links for making the post complete.
C++ forum:
http://www.cplusplus.com/forum/windows/51591/
Details explained:
http://www.cplusplus.com/reference/ios/dec/
Related
This question already has answers here:
Using scanf/printf to input into/output from a bitset
(3 answers)
Closed 5 months ago.
#include <bitset>
#include <assert.h>
#include <stdio.h>
using namespace std;
int main()
{
bitset<128> bs(42);
bs[11]=0;
bs[12]=1;
assert(bs[12]==1);
printf("bs[11]=%d\n", bs[11]);
printf("bs[12]=%d\n", bs[12]);
return 0;
}
console output:
Why can't I simply get 0 or 1 as output ?
printf with %d is for integer values, whereas std::bitset::operator[] returns a std::bitset::reference.
You can use std::cout from <iostream> header (which is anyway a more c++ "way" to print to the console):
#include <bitset>
#include <assert.h>
#include <iostream>
int main()
{
std::bitset<128> bs(42);
bs[11] = 0;
bs[12] = 1;
assert(bs[12] == 1);
std::cout << "bs[11]=" << bs[11] << std::endl;
std::cout << "bs[12]=" << bs[12] << std::endl;
return 0;
}
Output:
bs[11]=0
bs[12]=1
A side note: better to avoid using namespace std - see here Why is "using namespace std;" considered bad practice?.
With some review comments :
#include <cassert>
#include <bitset>
#include <iostream>
// anything with a .h extension is probably "C" not "C++"
// #include <assert.h>
//#include <stdio.h>
// using namespace std; <== NO, don't use using namespace std;
int main()
{
std::bitset<128> bs(42);
bs[11]=0;
bs[12]=1;
assert(bs[12]==1);
std::cout <<"bs[11]" << bs[11] << "\n";
std::cout << "bs[12]" << bs[11] << "\n";
return 0;
}
If you are using C++ then don't call printf to output something (my compiler refuse to compile your code correctly).
This C++ code works correctly using iostream:
#include <bitset>
#include <iostream>
int main()
{
std::bitset<128> bs(42);
bs[11]=0;
bs[12]=1;
std::cout << "bs[11]=" << bs[11] << std::endl;
std::cout << "bs[12]=" << bs[12] << std::endl;
return 0;
}
I am creating a random number generator for numbers between 110,000 and 320,000. When I run it, no numbers are above 150,000. Is there some way to make sure that numbers above 150,000 are generated? Even generating thousands of numbers do not work. I am aware I have lots of things included. Here is the code:
#include <stdlib.h>
#include <iostream>
#include <Windows.h>
#include <cstdlib>
#include <ctime>
#include <iostream>
#include <sstream>
#include <conio.h>
#include <ctime>
#include <random>
#include <cstdlib>
#include <ctime>
#include <iostream>
using namespace std;
int main() {
srand((unsigned) time(0));
int randomNumber;
for (int index = 0; index < 500; index++) {
randomNumber = (rand() % 320000) + 110000;
cout << randomNumber << endl;
}
}
As noted by John. You could use more recent random number generators easier to manipulate.
Adapting the code from C++ Reference about uniform_int_distribution
for your use case is straightforward:
#include <iostream>
#include <random>
int main(void) {
std::random_device rd; // Will be used to obtain a seed for the random number engine
std::mt19937 gen(rd()); // Standard mersenne_twister_engine seeded with rd()
std::uniform_int_distribution<> distrib(110000, 320000);
for (int n=0; n<10; ++n)
// Use `distrib` to transform the random unsigned int generated by
// gen into an int in [110000, 320000]
std::cout << distrib(gen) << ' ';
std::cout << '\n';
}
I am a new C++ programmer, I would like to ask you a simple question but I do not understand why output still give me repeating data:
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <fstream> // std::ifstream
#include <string.h>
#include <iostream>
#include <complex>
#include <sstream>
#include <vector>
#include <cmath>
#include <iomanip>
using namespace std;
int main(){
int nfft;
nfft = 256;
vector<float>f;
for(unsigned i=0; i<nfft; i++){
f.push_back(((i/(nfft-1))-0.5)*8e6);
}
for(unsigned i=0;i<nfft;i++){
cout << f[i] << endl;
}
}
My expectation is a vector: [-4.0000 -3.9686 -3.9373 -3.9059 -3.8745 -3.8431 -3.8118 -3.7804 -3.7490 -3.7176 -3.6863 -3.6549 ....... 3.9059 3.9373 3.9686 4.0000]
Please give me a hand to solve this problem.
Thank you so much.
(i/(nfft-1)) is well protected with parentheses and thus performs an integer division.
Since nfft > i you get zero => always the same value.
Example of how to ix:
f.push_back(((float(i)/(nfft-1))-0.5)*8e6)
For some reason I keep getting 6 every time. I know of another way to do a random dice roll, but I wanted to learn how to use the deafult_random_engine.
#include <iostream>
#include <string>
#include <random>
#include <ctime>
using namespace std;
int main()
{
default_random_engine randomGenerator(time(0));
uniform_int_distribution<int> diceRoll(1, 6);
cout << "You rolled a " << diceRoll(randomGenerator) << endl;
}
But this bit of code works with the time(0).
#include <iostream>
#include <cstdlib>
#include <ctime>
using namespace std;
int main()
// dice roll
{
srand(time(0));
for(int x = 1; x < 2; x++){
cout << 1+(rand()%6) << endl;
}
return 0;
}
It's almost certainly the use of time(0) as the culprit here.
You should probably opt for a method like this:
#include <iostream>
#include <string>
#include <chrono>
#include <random>
#include <ctime>
using namespace std;
int main() {
default_random_engine randomGenerator(std::random_device{}());
// OR:
// default_random_engine randomGenerator(
// (unsigned) chrono::system_clock::now().time_since_epoch().count());
uniform_int_distribution<int> diceRoll(1, 6);
cout << "You rolled a " << diceRoll(randomGenerator) << endl;
return 0;
}
While your original code always produced 6 on my system, this one seems a little more "adventurous":
pax> for i in {1..10}; do ./qq ; sleep 1 ; done
You rolled a 5
You rolled a 5
You rolled a 6
You rolled a 1
You rolled a 6
You rolled a 5
You rolled a 2
You rolled a 3
You rolled a 5
You rolled a 4
#include <iostream>
#include <string>
#include <random>
#include <ctime>
using namespace std;
int main()
{
mt19937 randomGenerator(time(0));
uniform_int_distribution<int> diceRoll(1, 6);
cout << "You rolled a " << diceRoll(randomGenerator) << endl;
}
I have a problem using atof,
here is the code:
#include <stdio.h>
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;
int main(){
std::string num ("1.0");
//std::string num ("1.1");
cout<< atof(num.c_str());
return 0;
}
If the num string is "1.1" , it can correctly cout 1.1. But if I want to keep the zero when the num string is "1.0" (want it to be 1.0 but not 1), what should I do?
You need to use std::fixed and std::setprecision, like so:
std::cout<< std::fixed << std::setprecision(1) << atof(num.c_str());
This will require that you include the iomanip header.
A possible solution is
#include <cstdio>
#include <iostream>
#include <string>
#include <iomanip>
int main() {
std::cout.precision(3);
std::cout.setf(std::ios::fixed);
std::string s("1.0");
float f = 0.0f;
sscanf(s.c_str(), "%f", &f);
// alternative way of setting this flags
// std::cout << std::fixed << std::setprecision(3) << f << "\n";
std::cout << f << "\n";
return (0);
}
notice that there are at least 2 ways of accomplishing the same format for the output, I left one of them commented out .