Quote:Original post by mrbastard

Quote:Original post by blaze02
9

I was going to laugh, but I got it wrong as well... I said 6. Will have to read the spec on preincrement and brackets I think.

It prints whatever the compiler wants to print. This statement has undefined behavior (google for sequence points for more information).

Edit: Or read Nathan's post :)

1. How do you add with out using addition, subtraction, modulus, multiply, divide operators.

// Originalint result = a + b; // Silly answer 1int result = a; result += b;// Silly answer 2int result = a, x = 0;while (x < b) { ++x; ++result; }while (x > b) { --x; --result; }// Useful answerstd::sum<int> op;int result = op(a,b);

2. How do you multiply without multiply operators

Same as above, with std::multiplies.

3. Whats so bad about iterating through an array of abstract objects?

Trick question, as "abstract object" is a vague expression. If you meant "abstract class instances", then the question is silly as there is no such thing as an abstract class instance.

4. Whats slower casting from float -> int or int -> float or are they the same?

Trick question. This behaviour is platform-dependent, and may even depend on the current pipeline status on a given platform.

5. Whats negative zero?

Trick question. C++ mentions no such thing as a "negative zero". However, IEEE 754 (one of the floating-point specifications) does mention negative zero (refer to that specification about the meaning of that expression). Of course, C++ has nothing to do with IEEE 754, as the specification of floating-point numbers in C++ is implementation-dependent. So, negative zero might well not exist in C++ on your platform!

6. Whats malloc? Whats new operator? Is there a difference? Why?

std::malloc is a memory allocation function from the C standard library (#include <cstdlib>), which operates in approximately the same way as the default void* ::operator new(std::size_t) overload of operator new. The differences are the return value (by default, new never returns a null pointer, and throws std::bad_alloc when out of memory), and the fact that std::malloc is used naked while ::operator new() almost never is. As with all C legacy allocators, the corresponding release function is std::free.

Operator new is a combination of two effects: operator new is a memory allocation function which may be overloaded by the programmer (although it must respect alignment and size constraints). A new-expression, when evaluated, calls the corresponding version of operator new (which may be overloaded for individual class hierarchies, and may receive additional arguments) to allocate memory, and then intializes an object at that location using the object's constructor. To each operator new corresponds an operator delete, which is used to release memory. In particular, when an exception occurs in a new-expression (for instance, thrown in the constructor), the corresponding operator delete is called on the allocated memory.

The main difference is that std::malloc does not initialize objects (although it is possible to use placement new post-allocation) and is not typesafe (as would obviously be expected from a raw memory allocator).

Thanks for all the ideas!
I just finished a few hours ago and they didn't really ask anything hard. the "hardest" thing that they asked was "what's the difference between overloading and overwriting":)