Home/ Questions/Q 7045
In Process
Alek Richter
  • 0
Enlightened
Asked: 2021-12-23T11:04:35+00:00

C error: undefined reference to function, but it IS defined

  • 0

Just a simple program, but I keep getting this compiler error. I’m using MinGW for the compiler.

Here’s the header file, point.h:

//type for a Cartesian point
typedef struct {
  double x;
  double y;
} Point;

Point create(double x, double y);
Point midpoint(Point p, Point q);

And here’s point.c:

//This is the implementation of the point type
#include "point.h"

int main() {
  return 0;
}
Point create(double x, double y) {
  Point p;
  p.x = x;
  p.y = y;
  return p;
}

Point midpoint(Point p, Point q) {
  Point mid;
  mid.x = (p.x + q.x) / 2;
  mid.y = (p.y + q.y) / 2;
  return mid;
}

And here’s where the compiler issue comes in. I keep getting:

testpoint.c: undefined reference to ‘create(double x, double y)’

While it is defined in point.c.

This is a separate file called testpoint.c:

#include "point.h"
#include <assert.h>
#include <stdio.h>
int main() {
  double x = 1;
  double y = 1;
  Point p = create(x, y);

  assert(p.x == 1);
  return 0;
}

I’m at a loss as to what the issue could be.

1 Answer

  2. Enlightened

    How are you doing the compiling and linking? You’ll need to specify both files, something like:

    gcc testpoint.c point.c

    …so that it knows to link the functions from both together. With the code as it’s written right now, however, you’ll then run into the opposite problem: multiple definitions of main. You’ll need/want to eliminate one (undoubtedly the one in point.c).

    In a larger program, you typically compile and link separately to avoid re-compiling anything that hasn’t changed. You normally specify what needs to be done via a makefile, and use make to do the work. In this case you’d have something like this:

    OBJS=testpoint.o point.o

testpoint.exe: $(OBJS)
    gcc $(OJBS)

    The first is just a macro for the names of the object files. You get it expanded with $(OBJS). The second is a rule to tell make 1) that the executable depends on the object files, and 2) telling it how to create the executable when/if it’s out of date compared to an object file.

    Most versions of make (including the one in MinGW I’m pretty sure) have a built-in “implicit rule” to tell them how to create an object file from a C source file. It normally looks roughly like this:

    .c.o:
    $(CC) -c $(CFLAGS) $<

    This assumes the name of the C compiler is in a macro named CC (implicitly defined like CC=gcc) and allows you to specify any flags you care about in a macro named CFLAGS (e.g., CFLAGS=-O3 to turn on optimization) and $< is a special macro that expands to the name of the source file.

    You typically store this in a file named Makefile, and to build your program, you just type make at the command line. It implicitly looks for a file named Makefile, and runs whatever rules it contains.

    The good point of this is that make automatically looks at the timestamps on the files, so it will only re-compile the files that have changed since the last time you compiled them (i.e., files where the “.c” file has a more recent time-stamp than the matching “.o” file).

    Also note that 1) there are lots of variations in how to use make when it comes to large projects, and 2) there are also lots of alternatives to make. I’ve only hit on the bare minimum of high points here.

    • 0
Leave an answer

Leave an answer

Browse