calling a function from a .h file

Question

file1.c => includes file1.h

file1.h => has a struct:

typedef struct {
  unsigned char *start;
  unsigned int startInt;
}debugPrint;

file1.c => creates a struct object:

debugPrint dp;

file1.c => an int is given into struct:

dp.startInt = 10;

file1.c => has a function:

void function1(debugPrint dp) {
  printf("%d", dp.startInt);
}

file2.h => has a function call to file1.c function which is declared before the call:

void function1(void);

function1();

Questions is:

• Is it ok that the file2.h calls a function from file1.c
• how can i pass the dp.startInt value to file2.h so that the value 10 that was set into dp.startInt in file1.c can be used in the funtion call in file2.h ?

It is needed to be called from file2.h since this file handles dynamic variable exchange between a html page and the file2.h file => data from file2.h function call via file1.c is sent to Html page. But i wont go more into the passing variable to html page since i don't know how it is made. It is a mechanism of openPicus web server example.

But if you know a good solution for this one. i would appreciate it. I'm not so familiar with this kind of code so that is also an issue here :)

But since i think this description is not good enough, here is the files:

file1.c:

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>
#include "test1.h"

// Define printStruct
void printStruct (debugPrint dp) {
    printf("%u", dp.startInt);
}

int main ()
{
    dp.startInt = 10;
    getch();
}

file1.h:

typedef struct {
    // For the motorEncoder value
    unsigned char filename[20];
    char ownMsg[10];
    unsigned char *start;
    unsigned char *timeInSeconds;
    unsigned char *distanceInCm;
    unsigned char *numberOfShots;
    unsigned char *shutterCompensation;
    unsigned char *direction;
    unsigned char *cancel;
    unsigned char *dutyCycle;
    unsigned int cancelInt;
    unsigned int startInt;
    unsigned int dutyCycleInt;
    unsigned int directionInt;
}debugPrint;

// Create struct object called dp
debugPrint dp;

// declare printStruct
void printStruct (debugPrint dp);

file2.h: (this file is totally needed to pass the dynamic values) I didn't put any includes since im not sure how i should include the .h files and from where i should include them.

// Call printStruct function
printStruct(dp);

part of file2.h actual code: (AND YES file2.h A HEADER FILE). FOR ME THIS SEEMS LIKE THE FUNCTIONS ARE FIRST DECLARED AND THEN ONE OF THEM IS USED IN THE H FILE => the HTTPPrint() function from where a function called HTTPPrint_stepCounter(); is called. That function is defined then in file1.c and it just prints some dynamic data to a http page. And as said this is how openPicus has done it and i am just trying to modify it.

void HTTPPrint(DWORD callbackID);
void HTTPPrint_led(WORD);
void HTTPPrint_stepCounter(void);

void HTTPPrint(DWORD callbackID)
{
    switch(callbackID)
    {
        case 0x00000017:
            HTTPPrint_led(0);
            break;
        case 0x00000059:
            HTTPPrint_stepCounter();
            break;
        default:
            // Output notification for undefined values
            TCPPutROMArray(sktHTTP, (ROM BYTE*)"!DEF", 4);
    }

    return;
}

void HTTPPrint_(void)
{
    TCPPut(sktHTTP, '~');
    return;
}

Answer 1

You claim that file2.h contains:

void function(void);

function1();

But these lines refer to two different functions.
^{This problem is now fixed; both names are function1}

If the function1(); appears outside any function, it is a (very sloppy) function declaration, not a function call. If it is inside some function, what is that function definition doing inside the header file. It would need to be an inline function to have much legitimacy.

^{The problem below is now fixed; the types are consistent.}
Additionally, you say: an integer is given into struct: dp[1].startInt = 10;. The compiler complains that you shouldn't assign integers to pointers (since startInt is declared as a pointer, not an int). You need to get your code to compile without such complaints.

... There are two versions of the structure defined, one at the top of the question where startInt is an unsigned int *startInt; and one later on where the declaration is unsigned int startInt. Please make your question self-consistent! ...

^{This problem has been fixed now; dp is a simple structure.}
Also note that you created debugPrint dp[1]; so your initialization is trampling out of bounds; the maximum valid index for the array is 0.

If code in file2.c needs to access the internals of the structure type declared in file1.h, the header file1.h should be included in file2.c. You can declare your dp array in the header too. A header should include other headers only if the functions it defines expose types defined in the other headers. For example, if the structure defined in file1.h included a FILE *db_fp; element, then file1.h should #include <stdio.h> to ensure that the code in file1.h would compile regardless of what else the code using file1.h includes.

Answer 2

Some tips for someone new to the C language:

There's an important difference between definition and declaration.

Definition is what actually creates the function or variable. Each function must be defined exactly once. Either in a *.c source file, or in a library.

Declaration creates an entry in the symbol table, that says the function or variable exists... somewhere... and here's its data type. Declarations can be duplicated without any effect.

We put function definitions in *.c source files. (And also in libraries, but that's an advanced build topic...)

We put public or extern function declarations in *.h header files. We put shared extern variable declarations in *.h header files, so that other source units can share the same variable. We put shared typedef structure declarations in *.h header files, so that other source units can share the same data type.

We do not put variable declarations in *.h header files if they aren't extern, or if they are initialized. The initial value belongs in the *.c file.

Function definitions usually don't belong in a *.h header file, because it's possible in a large project, that the header file could be included (read by the compiler) more than once. That would cause a compiler error, because then there would be more than one definition of that function. Even if it's literally a repeat of the same source code, there can be only one.

The quote about file2.h having a function call to file1.c function is not correct, function1(); could be either a declaration or a function call depending on context:

// declaration of a function named foo
void foo(void);
//
// declaration of a function named bar
// equivalent to declaring void bar(void);
bar();
//
// definition of a function named foo
void foo(void)
{
    // call (or invoke) the function named bar
    bar();
}

Another small point, about arrays: it's pretty strange to declare an array of one element debugPrint dp[1], since that declaration creates an object that will be referred to as dp[0]. This makes me think you may be trying to avoid the use of pointers... it would be more straightforward to just declare debugPrint dp and then the object is referred to as dp. Arrays make sense if you have more than one related object of the same type, but for just one object, it's a pretty unusual usage.

C is a very flexible programming language that gives free access to lots of low-level tricks. Both a blessing and a curse... For someone just getting started with the language, it's important to read other people's code examples as much as you can, to help learn how things are usually done. There are lots of extremely clever ways to use the language (e.g. Duff's Device) but in most cases, you're better off sticking with the most straightforward and customary way of solving the problem.

See also: What is the difference between a definition and a declaration?