Posts in Category "C"

C Puzzler – Give Me A Float

Time for another Puzzler! This time, let’s do a C Puzzler :) For those that don’t know what a Puzzler is, it is essentially a short problem used to demonstrate special cases or “features” of a particular language. Here is the format:

  1. Code – I introduce the code
  2. Question – I pose a multiple-choice question and you guess what the outcome is…think hard!
  3. Walkthrough – I walk through a reasonable explanation
  4. Answer – I tell you the real outcome (it might surprise you), and explain why
  5. Moral – How can we avoid making mistakes like this in our own code

Now that we all know what a Puzzler is, here is a simple C Puzzler:

Code:

// c-puzzler-give-me-a-float.c
#include <stdio.h>
 
int main()
{
	int x = 0.5 + giveMeAFloat();
 
	return x;
}
// c-puzzler-give-me-a-float-please.c
float giveMeAFloat()
{
	return 0.5;
}

Question:

What does this print?

  1. 0
  2. 1
  3. 1056964608
  4. it varies

Walkthrough:

There is a local variable, x, and it is declared as an int. It is being initialized to the sum of 0.5 and the value returned by the function giveMeAFloat, which is implemented in another source file. The function giveMeAFloat returns the float value 0.5, and so the sum of these two values is the float value 1.0. The variable x is an int, and so it will cast the value from 1.0 to 1. So, my answer is b, main returns the int value 1.

 

*SPOILER ALERT – ANSWER BELOW*


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Answer:

The answer is actually d – it varies! But, in practice, you will likely get c – 1056964608. How does this happen? Well, the astute observer will notice that in the source file containing our main function, there is no function prototype declaring the function giveMeAFloat. Because of this, and the fact that giveMeAFloat is implemented in another source file, then giveMeAFloat is *assumed* to return an int and not a float! If the method were declared and defined within the same source file, the compiler would detect this error and not complete the compilation. However, due to separate compilation, this cast goes unnoticed. And so, because of this ambiguity, depending on the compiler and the platform, how this value is treated and stored will vary from machine to machine! To better understand this, let’s look at the practical case where the answer is 1056964608.

  • This assumes that the program is being executed on a typical machine setup, with an x86 architecture running a current version of gcc (v4.x+)
    When the program is executed, within main, an int variable, x, is declared and initialized with a simple assignment expression that invokes giveMeAFloat. When giveMeAFloat returns, it stores the value 0.5 into the return register, eax. Since we are on a little-endian machine, this value is 0x3F000000. However, since the compiler is expecting to read an integer value, it interprets 0x3F000000 as an int and not a float, effectively loading the value 1056964608 (this is the decimal interpretation of the floating point hex representation of 0x3F000000…yikes!). Back in main, the value 0.5 gets added to this, resulting in the float value 1056964608.5. This subsequently gets assigned to the variable x. Since x is an int, this value gets cast and therefore truncated to 1056964608. And so main returns 1056964608.
     

As you can see, there are many factors that can affect the return value. In particular, what value the compiler stores into the return register (if anything), how that value is stored internally (endian-ness of the host machine), and how that value is subsequently read from the register (interpreted as int, or float, or other) all play a part. Due to all of these factors, the return value from main is effectively unpredictable, and should be treated as such (regardless of what the practical case would yield)!

Moral:

Given an arbitrary name that has not yet been previously declared, if the name is followed by a left parenthesis, it is defined to be a function and it is assumed to return an int. To prevent this, explicitly declare the function, either as a function prototype at the top of the source file, like so…

#include <stdio.h>
 
float giveMeAFloat();
 
int main()
{
	int x = 0.5 + giveMeAFloat();
 
	return x;
}

…or within the calling routine, like so…

#include <stdio.h>
 
int main()
{
	float giveMeAFloat();
	int x = 0.5 + giveMeAFloat();
 
	return x;
}

Now, there is no confusion, to yourself or the compiler, about the return-type of the function giveMeAFloat().

That’s been another C Puzzler! Hope you enjoyed! Happy coding!

 

 
Charles

c-puzzler-give-me-a-float.zip (source code)

Update: This post was corrected based on some feedback in the comments by Mihai. Thanks for the feedback, Mihai!

C Puzzler – Like Java Puzzlers, but for C!

I’m a big fan of Java Puzzlers. If you’re not familiar with what those are, I highly encourage you to watch this Google Tech Talk by Joshua Bloch. In short, Java Puzzlers are quirky pitfalls and corner-cases one might encounter when programming with the Java language. I liked the concept so much, I thought I’d add a section on my blog for my own puzzlers! The format is simple:

  1. Code – I introduce the code
  2. Question - I pose a multiple-choice question and you guess what the outcome is…think hard!
  3. Walkthrough - I walk through a reasonable explanation
  4. Answer - I tell you the real outcome (it might surprise you), and explain why
  5. Moral - How can we avoid making mistakes like this in our own code

Now that we know what a Puzzler is, here is a simple C Puzzler:

Code:

/** c-puzzler-lets-get-funcy.c **/
#include <stdio.h>
 
int funcOne();
int funcTwo();
 
int x = 1;
 
int main()
{
	int y = funcOne() + funcTwo();
 
	return y;
}
 
int funcOne()
{
	return x;
}
 
int funcTwo()
{
	return ++x;
}

Question:

What value does main return?

  1. 2
  2. 3
  3. 4
  4. it varies

Walkthrough:

There is a global variable, x, and it is initialized to 1. In main(), there is a local variable, y, and it is initialized to the value returned by funcOne() plus the value returned by funcTwo(). The function funcOne() simply returns the value stored in variable x, which is 1. The function funcTwo() also references x, but increments it in the process. Since the increment operator is a prefix, it performs the increment before returning the value, and so funcTwo() will return the incremented value of x, which is 2. Therefore, y will equal 1 + 2, which is 3, and main() will return the int value 3. So, my answer is b, main will return 3.

 

*SPOILER ALERT – ANSWER BELOW*


 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

Answer:

The answer is d – it varies. This is because in ANSI C, there is no guarantee as to the order in which the operands of an operator are evaluated. So, depending on the compiler implementation, funcOne() can be evaluated before funcTwo(), and vice versa, giving us a result of 3 or 4 depending on the compiler. It should be noted, though, that MOST C compilers will evaluate expressions of operands left to right, including the GNU compiler, but there is no guarantee that this is the case. As a result, the safest way to achieve compiler-agnostic results would be to use intermediary variables.

Moral:

The order in which operands of an operator is unspecified in C. So, to give safe and predictable results, external variables should be modified carefully, and specifically noted in the function’s documentation. If the documentation for a function is lacking, or you are working with a 3rd party API which, for all intents and purposes, is a black-box, use of intermediary variables to ensure order of operations is safest.

I hope you’ve enjoyed my first C Puzzler! Until next time, happy coding!

Charles

c-puzzler-lets-get-funcy.zip (source code)