In your source code, without much processing, probably the easiest way is with:

#define HI "hello world"
char str[] = HI " " HI " " HI;

This will declare a string of the requested value:

"hello world hello world hello world"

If you want code that will do it, you can use something like:

char *repeatStr (char *str, size_t count) {
    if (count == 0) return NULL;
    char *ret = malloc (strlen (str) * count + count);
    if (ret == NULL) return NULL;
    strcpy (ret, str);
    while (--count > 0) {
        strcat (ret, " ");
        strcat (ret, str);
    }
    return ret;
}

Now keep in mind this can be made more efficient - multiple strcat operations are ripe for optimisation to avoid processing the data over and over ^(a). But this should be a good enough start.

You're also responsible for freeing the memory returned by this function.

^(a) Such as with:

// Like strcat but returns location of the null terminator
//   so that the next myStrCat is more efficient.

char *myStrCat (char *s, char *a) {
    while (*s != '\0') s++;
    while (*a != '\0') *s++ = *a++;
    *s = '\0';
    return s;
}

char *repeatStr (char *str, size_t count) {
    if (count == 0) return NULL;
    char *ret = malloc (strlen (str) * count + count);
    if (ret == NULL) return NULL;
    *ret = '\0';
    char *tmp = myStrCat (ret, str);
    while (--count > 0) {
        tmp = myStrCat (tmp, " ");
        tmp = myStrCat (tmp, str);
    }
    return ret;
}

You can use the following technique:

printf("%.*s", 5, "=================");

This will print "=====" It works for me on Visual Studio, no reason it shouldn't work on all C compilers.

[Edit]

Note that this format specifier will print a left substring of the input, so the number you use has to be <= the width of the string

I consider this to be an X/Y problem (https://meta.stackexchange.com/questions/66377/what-is-the-xy-problem).

I suspect that creating a suitable repeated key string is a possible but inelegant solution.

Instead I propose to use the keys by accessing them via the modulo of the index you would use into the repeated string.

(I hereby admit to the concept being already in the noticably older comment by Weather Vane. I simply did not notice before adding my answer.)

I.e. instead of reading like this repeatedkeystring[i] access like keystring[i%keylength].

Note:
I trust/assume that "I'm making a vignere cipher implementation" means that you yourself can decide this kind of detail of accessing the keys. If you are using a library which requires e.g. a pointer to a sufficiently long character sequence in memory (pointer to char, const char* const, maybe), then you will admittedly need to follow the multiplying approach).

In C, char is an integer type; if you multiply a character by an integer, you're really multiplying two integer values. But the result may not be what you expect! For instance, try running this code:

int x = 'a' * 2;
char y = 'a' * 2;
printf("x: %d\n", x);
printf("y: %d\n", y);

On ideone.com, the output is:

x: 194
y: -62

Not only that, a string in C is represented by a character array, and there is no built-in support for multiplying arrays; you have to do it yourself with a loop. So even if you have the string type provided in the CS50 library, you're out of luck.

Python isn't the only language that has this functionality, but it's a feature that you should only expect to see in higher-level languages than C, particularly those referred to as "scripting" languages.

The default implementation of Python is actually built on C code, and your question piqued my curiosity, so I asked a question on StackOverflow to find out exactly how the Python feature is implemented in C. This is definitely more advanced, and not the way you would necessarily repeat a string in pure C code, but if you're interested: How is string multiplication implemented in CPython?