Array to function to int arithmetic

Question

I want to get the value of an integer from within a struct pointer. Simply: int cool = *(*(&(coolPtr->map)) + x); can this be simplified? The rest of the code is context. X being the index of the array.

struct Cool {
    int map[5];
};


int value (Cool* coolPtr, int x) {

    return *(*(&(coolPtr->map)) + x); // Here
} 


int main() {

// Test
Cool* foo = new Cool;

// Fill
for (int i = 0; i < 5; i++) foo->map[i] = i*4;

// Check
cout << value(foo, 3); cout << endl; // 12, correct
cout << value(foo, 4); cout << endl; // 16, correct

Answer 1

1. You should use one of the myriad accepted standard formatting-conventions.

   The things which stand out like a sore thumb are the newlines you have at the beginning of your two functions, the body of your for-loop being on the same line, and of course the content of main (which somehow lost it's closing bracket) having lost one level of indentation.
   Maybe the last is an artifact of not checking how it looks after posting here? Having taken a look at the source, that explanation seems unsatisfying...

2. You should avoid using namespace std; (The other line you omitted is obviously #include <iostream>). It's a plague and just biding its time to bite you later.
   Why is “using namespace std” considered bad practice?

3. Use '\n' instead of std::endl unless you might need to flush there.

4. You can chain uses of the stream-inserter.

5. Don't ever allocate something dynamically without a really good reason, and then use smart-pointers.

6. Your value-function isn't complex enough to be usefully extracted into a function in general.
   Still, let's dissect the expression:

   *(*(&(coolPtr->map)) + x);
   

   Which is:

   1. dereference `coolptr` and get member `map`
   2. take the address
   3. dereference (undoing last step)
   4. add `x`
   5. dereference (equal to indexing with `x` together with step 4)
   

   Equivalent:

   coolptr->map[x];
   

Answer 2

Yes, that can be simplified at lot.

*(&(coolPtr->map))

The * and & "cancel out" (assuming the expression is well-formed and both are otherwise legal), so you can drop them both, which leaves you with:

*(coolPtr->map + x)

Which people will recognize as the expanded form of array access, so you can put it back into its usual form:

coolPtr->map[x]