Thread: Array index vs. direct pointer

Originally Posted by dtkokovoko

Generally speaking, in C, is it generally more efficient to load a set of values into an array and access them in the code via indices, or is it better to malloc them into memory and address them directly?

Other than syntax, there should be no difference between the use of an index and the use of a pointer, assuming that you are using an optimising compiler. As for the difference between using an array and malloc: there is likely to be a small runtime penalty for the malloc call, but then typically more space can be allocated with malloc (unless you're dealing with an array with static storage duration), if you need it, and it is possible to realloc. In a sense, you will be "address(ing) them directly" either way.

Originally Posted by dtkokovoko

I would think that the array and the indices would add additional instructions in the compile that would make a high volume process noticeably slower.

You can always measure and find out.

It is generally more efficient to write code that is easiest for mere mortals to understand, and therefore easiest to get right, than indulging - as you are - in premature optimisation.

The answer to your question (which is more efficient) is really "they're generally the same but, if there is any difference, it depends" anyway. There is no general answer that is applicable across all possible ways of coding such things up, that works on all compilers, that work with all compiler optimisation settings.

It is not often that the eventual gains from such tweaking will exceed the cost of a few hours of programmer effort (even if we assume a low hourly rate) to implement it.

You might save a few microseconds or milliseconds per access, so you should only worry about such things if it has been demonstrated (eg by performance benchmarking and profiling) that the performance of the code really matters. Humans are notoriously ineffective at identifying the hotspots in their code, notoriously over-confident in their ability to do so, and inclined to spend hours of their time for small gains. In the quest for "efficiency", many programmers introduce more problems (bugs, untested failure conditions, etc) into their code - which means their code may be efficient and give the wrong results.

Starting without having identified hotspots in your code, and pursuing some generic thing called "efficiency", is a therefore waste of time.

Originally Posted by laserlight

... In a sense, you will be "address(ing) them directly" either way.

You can always measure and find out.

As far as addressing is concerned, I wasn't aware of how direct or indirect the array index method might be by comparison, and, while measurement (inspection) is always useful after the fact, I thought a bit of prevention might useful.

Truly great C code is not inscrutable.

It is one thing for a programmer with years of experience to understand the code written by another programmer with years of experience. It is quite another for a programmer with a few days or weeks of experience to understand code written by a programmer with years of experience. There is a whole bunch of knowledge that the experienced programmer has, and makes use of. Without that knowledge, the novice programmer will find the code harder to read.

IMHO, the problem needs to be addressed on three fronts. The first is that experienced programmers need to put in the time to avoid embedding obscure assumptions into their code unless they make the effort to clearly describe and justify those assumptions. Code that is written so only the three most experienced developers can understand it in a team of 500 is not good code.

The second is that novices need to spend time solving problems (writing code and documenting how it works), reading widely so they learn more about (in this case) C, and also some effort dissecting code written by others. Yes, some of that code will be terrible and some will be great. They key - when looking at other people's code - is forming your own opinions (What is this code doing? Why is it doing it this way and not that way? Would I do it that way? Why or why not? What approach would I use?)

The third is that people need to persist, because nothing comes easy the first time.


These things don't come easy. That's life. A native speaker of another language who wants to work with native english speakers will need to put in the effort - trial, error, false starts, etc - to learn english. Similarly, if an english speaker wants to work with people who speak another language. Both will find some basic things (basic grammar, a few key words that are often used) easy, but will trip up on more advanced things. It's the same thing with developing software. The only difference is that people, for some reason, expect software development to keep being easy.

Adak -

Is there a way to manage dynamic string arrays other than with pointers?

It would certainly be a welcome alternative!!!

Originally Posted by dtkokovoko

I would think that the array and the indices would add additional instructions in the compile that would make a high volume process noticeably slower.

From what I've read over the years, that used to be true more often than not. However over the years things have changed and more recently I've read that because the compiler must often assume that the pointer could point to anything, that it has less room for optimisation there. I've also read that the cost of code that does array indexing has changed with different processors as well.

Really, if everything I've read is to be believed, its just too close to call any more. Simply don't wory about it.

Originally Posted by dtkokovoko

I would think that the array and the indices would add additional instructions in the compile that would make a high volume process noticeably slower.

From what I've read over the years, that used to be true more often than not. However over the years things have changed and more recently I've read that because the compiler must often assume that the pointer could point to anything, that it has less room for optimisation there. I've also read that the cost of code that does array indexing has changed with different processors as well.

Really, if everything I've read is to be believed, its just too close to call any more. Simply don't wory about it.

Originally Posted by Adak

Other than programming guys and gals, people don't like using pointers. Their blood pressure rises dangerously just mentioning the term. Use indices.

Here is a simple test program

Code:

#include <stdio.h>

#ifdef USE_MYSTRCPY_V1
void mystrcpy(char *dest, char *src) 
{
    while (*src != '\0') {
        *dest = *src;
        dest++;
        src++;
    }
}
#endif

#ifdef USE_MYSTRCPY_V2
void mystrcpy(char *dest, char *src) 
{
    int i = 0;
    int j = 0;
    while (src[i] != '\0') {
        dest[i] = src[i];
        i++;
        j++;
    }
}
#endif

int main(void)
{
    char srcbuf[100] = "Hello, world!";
    char destbuf[100] = "";
    mystrcpy(destbuf, srcbuf);
    printf("%s\n", destbuf);    
    return 0;
}

Compile with:
gcc -Wall -DUSE_MYSTRCPY_V1 -std=c99 -Os -o v1 example.c
gcc -Wall -DUSE_MYSTRCPY_V2 -std=c99 -Os -o v2 example.c

Observations:
1. On MinGW GCC 4.7.2, assembler output of "mystrcpy" for both v1 and v2 is identical.
2. Compiling with other options for -O produces longer assembly for the index version.
3. "Programming guys and gals" that know C or C++ to a usable level should find the pointer version no less readable than the index version.
4. With too many indices, one can easily prefer the pointer version to the index version.

I think it comes down to an issue of style and what makes most sense. In this example, I find the pointer version to make the most sense. I personally don't really care about observationa 1 and 2, but just included them for interest's sake.

Sorry, I've no idea how I ended up with a duplicate post above as I did not post twice. I think IE must have done a dirty on me with that random question that sometimes comes up asking if I want to stay on the same page or leave the page. That question never makes sense so I don't know how to answer it. I just want it to do what it normally does!