回答2:

a[i] should be preferred, because it is more commonly used and so will be understood more quickly by the person reading the code.

回答3:

Although they are identical in arrays, I prefer a[i] for the following reason. Suppose you have code like this:

double gradient[3];

// 200 lines later
double dx = gradient[0]; // Works fine
double dy = *(gradient + 1); // Works just as well

Then somebody decided that std::vector looks better than double[]:

vector<double> gradient;

// 200 lines later
double dx = gradient[0]; // Still works
double dy = *(gradient + 1); // Ouch!

Then somebody else decided to go object-oriented all the way:

class Gradient
{
public:
    double operator[](int index) const; 
};

// 1000 lines later
Gradient gradient;

// 200 lines later
double dx = gradient[0]; // Still works
double dy = *(gradient + 1); // Ouch!!!

Thus, from the viewpoint of maintainability, I prefer to say exactly what I mean, without obscuring the intent with context-dependent synonyms. If I mean "take i-th element of a" then I say exactly that in C++ lingo:

a[i];

rather than relying that for the particular implementation of a one can use a fancier expression for the same.

回答4:

C has no operator overloading. So you are safe to use whichever you want.

回答5:

I would use a[i] for clarity when reading the code.

回答6:

Both are equivalent. Neither one is preferred over other but a[i] is commonly used by programmers. a[i] = *(a + i) = i[a]

回答7:

As far as I'm concerned (just finished a C course), there is no difference.

Array is implemented as a pointer to the first element on the stack. So a+1 is just the address on the stack after a :)

Edit: Also, as mentioned by John Bartholomew, even though they are the same, you might want to use a[i] instead - that is the "normal" way to do it (also in other languages) :)