C: prepend a literal to all strings in an array, while retaining access to the original strings

Question

Suppose one has an array of strings:

const char  str1[] = "some/path";
const char  str2[] = "another/path";
const char  str3[] = "and/a/third/path";
const char* strs[3];
strs[0] = str1;
strs[1] = str2;
strs[2] = str3;

Retaining the original definitions of the strings (i.e., str1, str2, and str3), I would like to be able to modify the paths in the array by one character under control of a preprocessor directive. The simplest way I have found to do this requires dropping the const qualifier, addition of a superfluous null byte, and shifting each element to the right.

char  str1[] = "some/path\0";
char  str2[] = "another/path\0";
char  str3[] = "and/a/third/path\0";
char* strs[3];
strs[0] = str1;
strs[1] = str2;
strs[2] = str3;
#ifdef build_option
for(int i=0; i<3; i++) {
    for(int j=strlen(strs[i]); j>=0; j--) {
        strs[i][j] = strs[i][j-1];
    }   
    strs[i][0] = '.'; // prepend each path with this character
}   
#endif

fprintf(stdout, "%s\n%s\n%s\n", strs[0], strs[1], strs[2]);

Output:

.some/path
.another/path
.and/a/third/path

This works well enough, but I wonder if there is a simpler or more idiomatic way of doing the same thing, preferably statically (though it doesn't have to be).

Edits:

To clarify the scenario, only the original string is needed in the primary compilation route; in a lesser used, alternate compilation route, both the original and modified strings are required. In the latter route, the modified form is the primary one, serving the same role as the original throughout the program (however, access to the original is still needed).

Thanks to all for the many great suggestions; a combination of them were used to arrive at the following:

#include <stdio.h>

//#define build_option  // rare compilation route

#ifdef build_option
    #define STR_OFFSET  0
#else
    #define STR_OFFSET  1
#endif

int
main(int argc, char *argv[])
{
    const char  str1[] = ".some/path";
    const char  str2[] = ".another/path";
    const char  str3[] = ".and/a/third/path";
    const char* strs[3] = { str1,
                            str2,
                            str3 };

    for(int i=0; i<3; i++)
        fprintf(stdout, "%s\n",strs[i]+STR_OFFSET);

    #ifdef build_option
    fprintf(stdout, "\noriginal:\n");
    for(int i=0; i<3; i++)
        fprintf(stdout, "%s\n",strs[i]+1);
    #endif

    return 0;
}

Without build_option defined, this gives

some/path
another/path
and/a/third/path

With build_option defined, this gives

.some/path
.another/path
.and/a/third/path

original:
some/path
another/path
and/a/third/path

Answer 1

Compile time solution:

#include <stdio.h>

#ifdef build_option
  #define PATH(str) "."str
#else
  #define PATH(str) str
#endif

const char  str1[] = PATH("some/path");
const char  str2[] = PATH("another/path");
const char  str3[] = PATH("and/a/third/path");
const char* strs[3] = { str1, str2, str3 };

int main()
{
  for(int i = 0; i < 3; ++i)
  {
    printf("%s\n", strs[i]);
  }
  return 0;
}

How does it work? Well, you just have to know that you can naturally concatenate string literals. Either google it or have a look at this stackoverflow thread. The rest is normal macro stuff. No runtime disadvantage, no memory allocation, no copying.

Answer 2

Use malloc() to allocate new strings and copy from the literals to them.

const char* strs[] = {"some/path", "another/path", "and/a/third/path"};
const int numstrs = sizeof strs / sizeof strs[0];
char *newstrs[numstrs];
for (int i = 0; i < numstrs; i++) {
    newstrs[i] = malloc(strlen(strs[i] + 2)); // +2 for added prefix and null byte
    newstrs[i][0] = '.';
    strcpy(&newstrs[i][1], strs[i]);
}

Answer 3

You can do it at compile time without modifying the content of the strings, but take note that this method only works if the characters you want to replace are at the end or the beginning of a string literal.

#ifdef build_option
  #define TK1 "."
#else
  #define TK1 ""
#endif

void main(void) {
  const char  str1[] = TK1"some/path";
  const char  str2[] = TK1"another/path";
  const char  str3[] = TK1"and/a/third/path";
  const char* strs[3];
  strs[0] = str1;
  strs[1] = str2;
  strs[2] = str3;
 }

Answer 4

There is no need for separate arrays unless you want to access them separately by name:

#if defined build_option
    #define MyPrefix "."
#else
    #define MyPrefix
#endif

const char *strs[] =
{
    MyPrefix "some/path",
    MyPrefix "another/path",
    MyPrefix "and/a/third/path",
};

Adjacent string literals are concatenated after preprocessing and before main compilation (semantic analysis and translation).

Here is a solution that defines both the original and modified strings:

#define DefineMyStrings(name, prefix) \
    char *name[] =                    \
    {                                 \
        prefix "some/path",         \
        prefix "another/path",      \
        prefix "and/a/third/path",  \
    };

DefineMyStrings(original,)
DefineMyStrings(prefixed, ".")


#include <stdio.h>


#define NumberOf(a) (sizeof (a) / sizeof *(a))

int main(void)
{
    for (int i = 0; i < NumberOf(original); ++i)
        printf("original[%d] = %s.\n", i, original[i]);

    for (int i = 0; i < NumberOf(prefixed); ++i)
        printf("prefixed[%d] = %s.\n", i, prefixed[i]);
}

Answer 5

Here is a possible static solution

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

static char *strsrc[] = {
        "some/path",
        "another/path",
        "and/a/third/path",
};
static char strdst[3][BUFSIZ];

int main(void)
{
        for (int i = 0; i < 3; i++) {
                strncpy(&strdst[i][1], strsrc[i], BUFSIZ); 
                strdst[i][0] = '.';
                puts(strdst[i]);
        }
        return 0;
}

I just copied the string to the destination offeseted and then overwrite the first character. Constants are already null terminated so no need to '\0' them.

Regards,