integer-overflow

This question is a result of another SO question . Example Code #include <iostream> int main() { unsigned long b = 35000000; int i = 100; int j = 30000000; unsigned long n = ( i * j ) / b; // #1 unsigned long m = ( 100 * 30000000 ) / b; // #2 std::cout << n << std::endl; std::cout << m << std::endl; } Output 85 85 Compiling this code with g++ -std=c++11 -Wall -pedantic -O0 -Wextra gives the following warning: 9:28: warning: integer overflow in expression [-Woverflow] Questions Am I correct in thinking that #1 and #2 invoke undefined behavior because the intermediate result 100 * 30000000 does

Is it possible to execute a process whose argc = 0? I need to execute a program but it is extremely important for its argc to be equal to 0. Is there a way to do that? I tried to put 2^32 arguments in the command line so that it appears as if argc = 0 but there is a maximum limit to the number of arguments. You can write a program that calls exec directly; that allows you to specify the command-line arguments (including the program name) and lack thereof. You may use linux system call execve() . int execve(const char *filename, char *const argv[], char *const envp[]); You may pass the filename

In the following program, the line 5 does give overflow warning as expected, but surprisingly the line 4 doesn't give any warning in GCC: http://www.ideone.com/U0BXn int main() { int i = 256; char c1 = i; //line 4 char c2 = 256; //line 5 return 0; } I was thinking both lines should give overflow warning. Or is there something I'm missing? The topic which led me to do this experiment is this: typedef type checking? There I said the following(which I deleted from my answer, because when I run it, it didn't show up as I had expected): //However, you'll get warning for this case: typedef int T1;

I am trying to understand arithmetic overflow. Suppose I have the following, unsigned long long x; unsigned int y, z; x = y*z; y*z can lead to an integer overflow. Does casting one of the operands to an unsigned long long alleviate this issue. What is the expected result of the multiplication of a 64-bit operand with a 32-bit operand? unsigned long long x; unsigned int y, z; x = y*z; The evaluation of the expression y*z is not affected by the context in which it appears. It multiplies two unsigned int values, yielding an unsigned int result. If the mathematical result cannot be represented as

Consider the following as a reference implementation: /* calculates (a * b) / c */ uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c) { uint64_t x = a; x = x * b; x = x / c; return x; } I am interested in an implementation (in C or pseudocode) that does not require a 64-bit integer type. I started sketching an implementation that outlines like this: /* calculates (a * b) / c */ uint32_t muldiv(uint32_t a, uint32_t b, uint32_t c) { uint32_t d1, d2, d1d2; d1 = (1 << 10); d2 = (1 << 10); d1d2 = (1 << 20); /* d1 * d2 */ return ((a / d1) * (b /d2)) / (c / d1d2); } But the difficulty is to pick

Let's say I have a char pointer: char * cp; int val2 = 2; cp = &val2; *cp = 1234; What will happen since the value 1234 is too large to fit in 1 byte? Will it just overflow and cause incorrect values to be stored, or will it somehow store the correct value across several bytes? In *cp = 1234; , *cp refers to just one byte, the first (lowest-addressed) byte of val2 . In an assignment, the value of the right-hand side is converted to the type of the left side. So, 1234 will be converted to char . There are two complications here. One, in most C implementations, 1234 is too big to fit into a char