printf with a width modifier fails to print the value - c++

In a C++ program, under Windows 7 using VS2013 and under Ubuntu 14.04.1 using g++ 4.6, I am mystified by the operation of printf().
With the 2nd width modifier, this prints a space instead of a 0.
When set to another value, e.g., -1, it prints it. Without the modifier, it prints a 0, as expected.
I pasted the actual, relevant code into another program and it behaved the same way.
What could be the problem?
#include <stdio.h>
int main(){
int x = 1, z = 0;
printf ("%2.d: %2.d\n", x, z); // fails to print 0
printf ("%2.d: %d\n", x, z); // 2nd %2. absent, prints as expected
return 0;
}
Output:
1:
1: 0


The point should go to the left
#include <stdio.h>
int main()
{
int x = 1, z = 0;
printf ("%.2d: %.2d\n", x, z); // fails to print 0
printf ("%.2d: %d\n", x, z); // 2nd %2. absent, prints as expected
return 0;
}
Output:
01: 00
01: 0

Related

round() function produces a strange number

I declare double variables t and tau, and assign them values 1 and 0.00001
This line of code produces 536870912 in the console. What can be the reason?
printf("%i\n",round(t/(tau*double(2))));
By the way, I write code in a C++ compiler, but practically it's C.

round returns a double. Printing it with %i is undefined behaviour.
Use %f for printing double:
printf("%f\n",round(t/(tau*double(2))));

Use %lf instead of %i and remove double line it is unnecessary because you are already defined variables as double.
#include <stdio.h>
#include <math.h>
int main()
{
double t = 1, tau = 0.00001;
printf("%lf\n", round(t/(tau*2)));
return 0;
}
Output -: 50000.000000
If you want 50000 only you can edit your code into like this
double t = 1, tau = 0.00001;
int answer;
answer = round(t/(tau*2));
printf("%i\n", answer);
Output -: 50000

Printing negative numbers created on the fly gives incorrect output in c++

Following code explains a quirk, and I am unable to understand why it is the way it is. The comments in the code explain the quirk:
#include <iostream>
#include <string>
using namespace std;
int main() {
string a,b;
a = "abc";
b = "def";
// On the fly calculation of diff does not lead to desirable results.
cout<<"a size: "<<a.size()<<" b size: "<<b.size()<<" diff: "<<a.size()-b.size()-1<<endl;
// Following assignment works as expected.
int diff = a.size()-b.size()-1;
cout<<"diff "<<diff<<endl;
for (int i=a.size()-1; i>a.size()-b.size()-1; --i) {
cout<<"running"<<endl;
}
return 0;
}
Here is the output I get:
a size: 3 b size: 3 diff: 4294967295
diff: -1

a.size()-b.size()-1
Since the size method returns a size_t, i.e. an unsigned value, you're computing 3-3-1 = -1 in an "unsigned space" which gives you a wrong value.
Try:
int(a.size())-int(b.size())-1

Run ARM coprocessor instructions with sudo

My goal is to write to the coprocessor p15 register, and right now I'm just trying to read it.
I have the following example c++ program, the first asm instruction is just a simple ror, which works just fine. The second asm instruction, I'm trying to just read SCTLR register.
I compile the program with g++ test_program.cpp -o test
and run with ./test or sudo ./test
If I run with ./test, I get the output:
Value: 10 Result: 8
Illegal instruction
If I run with sudo ./test, I get:
Value: 10 Result: 8
So clearly the instruction is not working since its not printing the line "got here" or "SCTLR". Is there something else I have to do to execute the coprocessor read? I'm running this on a raspberry pi (Cortex A-53).
#include <cstdlib>
#include <cstdio>
int main(){
unsigned int y, x;
x = 16;
//Assembly rotate right 1 example
asm("mov %[result], %[value], ror #1"
: [result]"=r" (y) /* Rotation result. */
: [value]"r" (x) /* Rotated value. */
: /* No clobbers */
);
printf("Value: %x Result: %x\n", x, y);
// Assembly read SCTLR, program crashes if this is run
unsigned int id = 0;
asm("MRC p15, 0, %[result], c0, c0, 0"
: [result]"=r" (id) //Rotation result.
);
printf("Got here\n");
printf("SCTLR: %x", id);
return 0;
}

Same Code giving different results in Visual Studio 2010 and Code Blocks 10.05

I am executing a filter code .This Code gives different results in Visual Studio and Code Blocks.Expected Results are the results which code blocks gives.But As i have to implement Intel Thread Building Blocks into it i have to use Visual Studio.Please help in finding why the difference is there.
Code is :
#include <stdio.h>
#include <stdint.h>
#include <cstring>
#include <iostream>
#include <fstream>
#include <math.h>
#include <time.h>
using namespace std;
#define pi 3.141593
#define FILTER_LEN 265
double coeffs[ FILTER_LEN ] =
{
0.0033473431384214393,0.000032074683390218124,0.0033131082058404943,0.0024777666109278788,
-0.0008968429179843104,-0.0031973449396977684,-0.003430943381749411,-0.0029796565504781646,
-0.002770673157048994,-0.0022783059845596586,-0.0008531818129514857,0.001115432556294998,
0.0026079871108133294,0.003012423848769931,0.002461420635709332,0.0014154004589753215,
0.00025190669718400967,-0.0007608257014963959,-0.0013703600874774068,-0.0014133823230551277,
-0.0009759556503342884,-0.00039687498737139273,-0.00007527524701314324,-0.00024181463305012626,
-0.0008521761947454302,-0.00162618205097997,-0.002170446498273018,-0.002129903305507943,
-0.001333859049002249,0.00010700092934983156,0.0018039564602637683,0.0032107930896349583,
0.0038325849735515363,0.003416201274366522,0.002060848732332109,0.00017954815260431595,
-0.0016358832300944531,-0.0028402136847527387,-0.0031256650498727384,-0.0025374271571154713,
-0.001438370315670195,-0.00035115295209013755,0.0002606730012030533,0.0001969569787142967,
-0.00039635535951198597,-0.0010886127490608972,-0.0013530057243606405,-0.0008123200399262436,
0.0005730271959526784,0.0024419465938120906,0.004133717273258681,0.0049402122577746265,
0.0043879285604252714,0.002449549610687005,-0.00040283102645093463,-0.003337730734820209,
-0.0054508346511294775,-0.006093057767824609,-0.005117609782189977,-0.0029293645861970417,
-0.0003251033117661085,0.0018074390555649442,0.0028351284091668164,0.002623563404428517,
0.0015692864792199496,0.0004127664681096788,-0.00009249878881824428,0.0004690173244168184,
0.001964334172374759,0.0037256715492873485,0.004809640399145206,0.004395274594482053,
0.0021650921193604,-0.0014888595443799124,-0.005534807968511709,-0.008642334104607624,
-0.009668950651149259,-0.008104732391434574,-0.004299972815463919,0.0006184612821881392,
0.005136551428636121,0.007907786753766152,0.008241212326068366,0.00634786595941524,
0.003235610213062744,0.00028882736660937287,-0.001320994685952108,-0.0011237433853145615,
0.00044213409507615003,0.0022057106517524255,0.00277593527678719,0.0011909915058737617,
-0.0025807757230413447,-0.007497632882437637,-0.011739520895818884,-0.013377018279057393,
-0.011166543231844196,-0.005133056165990026,0.0032948631959114935,0.011673660427968408,
0.017376415708412904,0.018548938130314566,0.014811760899506572,0.007450782505155853,
-0.001019540069785369,-0.007805775815783898,-0.010898333714715424,-0.00985364043415772,
-0.005988406030111452,-0.001818560524968024,0.000028552677472614846,-0.0019938756495376363,
-0.007477684025727061,-0.013989430449615033,-0.017870518868849213,-0.015639422062597726,
-0.005624959109456065,0.010993528170353541,0.03001263681283932,0.04527492462846608,
0.050581340787164114,0.041949186532860346,0.019360612460662185,-0.012644336735920483,
-0.0458782599058412,-0.07073838953156347,-0.0791205623455818,-0.06709535677423759,
-0.03644544574795176,0.005505370370858695,0.04780486657828151,0.07898800597378192,
0.0904453420042807,0.07898800597378192,0.04780486657828151,0.005505370370858695,
-0.03644544574795176,-0.06709535677423759,-0.0791205623455818,-0.07073838953156347,
-0.0458782599058412,-0.012644336735920483,0.019360612460662185,0.041949186532860346,
0.050581340787164114,0.04527492462846608,0.03001263681283932,0.010993528170353541,
-0.005624959109456065,-0.015639422062597726,-0.017870518868849213,-0.013989430449615033,
-0.007477684025727061,-0.0019938756495376363,0.000028552677472614846,-0.001818560524968024,
-0.005988406030111452,-0.00985364043415772,-0.010898333714715424,-0.007805775815783898,
-0.001019540069785369,0.007450782505155853,0.014811760899506572,0.018548938130314566,
0.017376415708412904,0.011673660427968408,0.0032948631959114935,-0.005133056165990026,
-0.011166543231844196,-0.013377018279057393,-0.011739520895818884,-0.007497632882437637,
-0.0025807757230413447,0.0011909915058737617,0.00277593527678719,0.0022057106517524255,
0.00044213409507615003,-0.0011237433853145615,-0.001320994685952108,0.00028882736660937287,
0.003235610213062744,0.00634786595941524,0.008241212326068366,0.007907786753766152,
0.005136551428636121,0.0006184612821881392,-0.004299972815463919,-0.008104732391434574,
-0.009668950651149259,-0.008642334104607624,-0.005534807968511709,-0.0014888595443799124,
0.0021650921193604,0.004395274594482053,0.004809640399145206,0.0037256715492873485,
0.001964334172374759,0.0004690173244168184,-0.00009249878881824428,0.0004127664681096788,
0.0015692864792199496,0.002623563404428517,0.0028351284091668164,0.0018074390555649442,
-0.0003251033117661085,-0.0029293645861970417,-0.005117609782189977,-0.006093057767824609,
-0.0054508346511294775,-0.003337730734820209,-0.00040283102645093463,0.002449549610687005,
0.0043879285604252714,0.0049402122577746265,0.004133717273258681,0.0024419465938120906,
0.0005730271959526784,-0.0008123200399262436,-0.0013530057243606405,-0.0010886127490608972,
-0.00039635535951198597,0.0001969569787142967,0.0002606730012030533,-0.00035115295209013755,
-0.001438370315670195,-0.0025374271571154713,-0.0031256650498727384,-0.0028402136847527387,
-0.0016358832300944531,0.00017954815260431595,0.002060848732332109,0.003416201274366522,
0.0038325849735515363,0.0032107930896349583,0.0018039564602637683,0.00010700092934983156,
-0.001333859049002249,-0.002129903305507943,-0.002170446498273018,-0.00162618205097997,
-0.0008521761947454302,-0.00024181463305012626,-0.00007527524701314324,-0.00039687498737139273,
-0.0009759556503342884,-0.0014133823230551277,-0.0013703600874774068,-0.0007608257014963959,
0.00025190669718400967,0.0014154004589753215,0.002461420635709332,0.003012423848769931,
0.0026079871108133294,0.001115432556294998,-0.0008531818129514857,-0.0022783059845596586,
-0.002770673157048994,-0.0029796565504781646,-0.003430943381749411,-0.0031973449396977684,
-0.0008968429179843104,0.0024777666109278788,0.0033131082058404943,0.000032074683390218124,
0.0033473431384214393
};
void ComputeFIR(double *coeffs, double *input, int filterLength,ofstream &o )
{
double acc;
double *coeffp;
int n,k,ip,nip;
o<<fixed;
for ( n = 0; n < 150000; n++ )
{
coeffp = coeffs;
ip=(filterLength - 1 + n);
nip=0;
acc = 0;
for ( k = 0; k < filterLength; k++ )
{
nip=ip-k;
acc += ((*coeffp++) * (input[nip])); // *inputp-- we can't use bcoz dynamic memory is not neccasarily in sequence);
}
o<<n<<","<<acc<<endl;
if(n<10)
{
cout<<n<<"\t"<<acc<<endl;
}
}
}
int main()
{
int i;
ofstream o("400hz.csv");
cout<<fixed;
o<<fixed;
double *buffer=new double[150264]; // Length required to process M input samples is N-1+M where N is MAC , M is the Number of samples
memset(buffer, 0, sizeof( buffer));
for(i =(FILTER_LEN - 1); i < 150264; i++)
{
buffer[i] = sin(400 * (2 * pi) * (i / 5000.0));
o<<i<<","<<buffer[i]<<endl;
}
ComputeFIR( coeffs,buffer,FILTER_LEN,o );
delete []buffer;
return 0;
}
In this code part
if(n<10)
{
cout<<n<<"\t"<<acc<<endl;
}
gives results in code blocks as
0 0.002291
1 0.003205
2 0.005587
3 0.007458
4 0.006254
5 0.001537
6 -0.005113
7 -0.011685
8 -0.0016522
9 -0.018142
which are as expected
and in Visual Studio results are
0 7.86052E+64
1 7.88065E+64
2 9.96043E+64
3 1.15158E+65
4 1.09528E+65
5 8.94574E+64
6 6.79198E+64
7 4.92152E+64
8 3.18225E+64
9 1.75206E+64
Please help in resolving this issue.

The following line doesn't initialise your buffer to zero:
memset(buffer, 0, sizeof( buffer));
You need
memset(buffer, 0, sizeof(double) * 150264);
Maybe CodeBlocks and VS2012 differ in the way that they are initialising that buffer.

Having the same code do different result when using different compilers is a sure sign of undefined behavior.
The reason behind this undefined behavior is because of this:
memset(buffer, 0, sizeof( buffer));
The first problem is that the variable buffer is a pointer, and so using sizeof(buffer) you get the size of the actual pointer and not what it points to. This means that only four or eight bytes (depending on if you have a 32 or 64 bit platform) will be initialized to zero. The rest of the memory will be seemingly random.
The second problem, which works in this case (but only in this case), is that you are setting all data to zero. Floating point numbers are not stored like normal integer numbers in memory. You can't use memset with any other value and expect the numbers to be what you want.

uninitialized local variable

This code compiles and runs though gives a Microsoft compiler error that I cant fix
warning C4700: uninitialized local variable '' used.
This is in the last line of the code, I think
#include <iostream>
using namespace std;
const int DIM0 = 2, DIM1 = 3, DIM2 = 4, DIM3 = 5;
void TestDeclar();
int main(){
TestDeclar();
cout << "Done!\n";
return 0;
}
void TestDeclar(){
//24 - array of 5 floats
float xa[DIM3], xb[DIM3], xc[DIM3], xd[DIM3], xe[DIM3], xf[DIM3];
float xg[DIM3], xh[DIM3], xi[DIM3], xj[DIM3], xk[DIM3], xl[DIM3];
float xm[DIM3], xn[DIM3], xo[DIM3], xp[DIM3], xq[DIM3], xr[DIM3];
float xs[DIM3], xt[DIM3], xu[DIM3], xv[DIM3], xw[DIM3], xx[DIM3];
//6 - array of 4 pointers to floats
float *ya[DIM2] = {xa, xb, xc, xd}, *yb[DIM2] = {xe, xf, xg, xh};
float *yc[DIM2] = {xi, xj, xk, xl}, *yd[DIM2] = {xm, xn, xo, xp};
float *ye[DIM2] = {xq, xr, xs, xt}, *yf[DIM2] = {xu, xv, xw, xx};
//2 - array of 3 pointers to pointers of floats
float **za[DIM1] = {ya, yb, yc};
float **zb[DIM1] = {yd, ye, yf};
//array of 2 pointers to pointers to pointers of floats
float ***ptr[DIM0] = {za, zb};
cout << &***ptr[DIM0] << '\n';
}

You're accessing past the end of the ptr4D. DIM0 is 2, one greater than the last index of 1!
Change the last few lines to:
//array of 2 pointers to pointers to pointers of floats
float ***ptr4D[DIM0] = {za, zb};
cout << &***ptr4D[0] << '\n';

Not sure if I can help you but I tried to find out what's wrong trying to run it on my linux machine. I've compiled it on a ubuntu machine to compare and it went ok, even tellign the compiler to turn on all option warnings (passing the -Wall option). When running, I got this:
# Compiled it with -Wall to enable all warning flags and -g3 to produce extra debug information
~$ g++ -Wall stackoverflow.cpp -g3
./a.out
Segmentation fault (core dumped)
Then I've tried to debug it with GDB (GNU debugger) and got this:
(gdb) r
Starting program: /home/ubuntu/a.out
Program received signal SIGSEGV, Segmentation fault.
0x0000000000400986 in TestDeclar () at stackoverflow.cpp:34
34 cout << &***ptr4D[DIM0] << '\n';
(gdb) s
So it appears that the problem is at the cout line. Checking your code again, DIM0's value is 2, so you're trying to access a memory address beyond the ptr4D. As user1721424 mentioned, just replace the DIM0 with 0 and it's done!
#After fixing it:
~$ ./a.out
0x7fff74cd3830
Done!
Hope it helps!