Multiple Definition of textFileRead(char*)

Question

I'm using this header file to read textfiles ( I use it to load shader files) and I use it in two different classes.

I'm getting the error Multiple Definition of textFileRead(char*).

Here is the header file:

#ifndef READFILE_H
#define READFILE_H

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
#include "string"
#include "fstream"

char *textFileRead(char *fn) {

FILE *fp;
char *content = NULL;

int count=0;

if (fn != NULL) {
    fp = fopen(fn,"rt");

    if (fp != NULL) {

  fseek(fp, 0, SEEK_END);
  count = ftell(fp);
  rewind(fp);

        if (count > 0) {
            content = (char *)malloc(sizeof(char) * (count+1));
            count = fread(content,sizeof(char),count,fp);
            content[count] = '\0';
        }
        fclose(fp);
    }
}
return content;
}


#endif READFILE_H

what am I doing wrong?

Answer 1

You need to make sure the code from your header file is included once only for each compilation unit. To do this, you put this at the beginning of the file:

#ifndef READFILE_H
#define READFILE_H

and this at the end:

#endif

Of course, the identifier READFILE_H should be unique for each file. Next thing to do is: leave only declarations of your functions and classes in your header, implementations should live in a separate implementation file (.c or .cpp or .cc). So in your header you will have declaration of your function only:

char *textFileRead(char *);

and the definition of your function will be in a separate .c file.

Answer 2

Functions defined in the header need to be marked as inline to prevent multiple definition.

Either this, or separate the implementation to an implementation file.

Include guards guard against multiple definition in the same translation unit, this is a linker problem. The symbol is defined multiple times across translation units.

Answer 3

You're defining the function in the header file, which means that the compiler will make a copy of the same function in each source file where you include this header. When it comes to linking the object files the linker will not know which version to use. (It can not know they are the same, just that their signatures are the same.)

One way to fix this is to move the implementation to a source file, and leave the declaration in the header file, like this:

readfile.h

#ifndef READFILE_H
#define READFILE_H

char *textFileRead(char *fn);

#endif

readfile.cpp

#include "readfile.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <fstream>

char *textFileRead(char *fn) 
{
    FILE *fp;
    char *content = NULL;
    int count=0;

    /* ... code ... */

    return content;
}

Another solution is to mark the function inline and leave the implementation in the header file. Like this:

#ifndef READFILE_H
#define READFILE_H

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

inline char *textFileRead(char *fn) 
{
    FILE *fp;
    char *content = NULL;

    /* ... code ... */

    return content;
}

In this last case, the compiler may choose to inline the function where it is called rather than generating a call to it.

It is also possible to use static in place of inline in the above example, or to surround the definition in an anonymous namespace. However neither of these methods are recommended. Unless you have specific reasons you want to potentially inline your function and make its body available in the header file, I'd go for the first alternative.