Thread: Breaking up source code into multiple files

Ok, I'm messing around trying to learn C and got my code working but it was just one large .c file. Now I wanted to break it up into multiple files so it would be easier to see what's going on but ran into some issues. I would appreciate any help with this.

main.c

Code:

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

int main()
{
	char *name;
	name = strdup_func("Brian Gable");
	struct employee *eptr = malloc(sizeof *eptr);
	
	build_employee( eptr);
	printf("Empolyee name is: %s\n",eptr->name);
	printf("Empolyee age is: %d\n",eptr->age);
	printf("Empolyee address is: %s\n",eptr->address);
	strcpy(eptr->name,name);
	printf("Empolyee name is: %s\n",eptr->name);
	printf("Empolyee age is: %d\n",eptr->age);
	printf("Empolyee address is: %s\n",eptr->address);
	name = substrg(name,1,5);
	printf("Substring: %s\n", name);
	name = reverse_string(name);
	printf("Substring reversed: %s\n", name);
	
	return (0);	
}

functions.c

Code:

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

void build_employee(struct employee *employee_pointer)
{
	strcpy(employee_pointer->name, "Michael Clark");
	employee_pointer->age = 29;
	strcpy(employee_pointer->address, "3302 Runner Rd Apt 107");
	
}

char *strdup_func(char *instr)
{
	char *outstr;
	if (!instr)
	{
		fprintf(stderr, "strdup: FATAL - NULL argument!\n");
		return(NULL);
	}
	
	outstr = (char *) malloc(sizeof(char) * (strlen(instr)+1) );
	if (!outstr)
	{
		fprintf(stderr, "strdup: FATAL - malloc failed!");
		return(NULL);
	}
	
	strcpy(outstr, instr);
	
	return(outstr);
}

char *substrg(char *first_string, int start, int numchars)
{
	char *p;
	
	int count = 0, length = 0;
	
	length = strlen(first_string);
	
	if(start > length || length < 2 || start < 1)
	{
		return (NULL);
	}
	
	p = (char *) malloc(sizeof(char) * (numchars+1));
	
	start--;
	
	while (count < numchars)
	{
		p[count]= *(first_string+start+count);
		count++;
	}
	p[count] = '\0';	
	return (p);
	
}

char *reverse_string(char *string)
{
	char *p;
	int slen = 0, count = 0;
	slen = strlen(string);
	p = (char *) malloc(sizeof(char) * (slen+1));
	
	while (string[count] != '\0')
	{
		p[--slen]=string[count++];
	}
	
	return (p);
}
void update_employee_name(struct employee *employee_pointer, char new_name[80])
{
	strcpy(employee_pointer->name, new_name);
}

functions.h

Code:

#ifndef FUNC_H
#define FUNC_H

void build_employee(struct employee *employee_pointer);
char *strdup_func(char *instr);
char *substrg(char *first_string, int start, int numchars);
char *reverse_string(char *string);
void update_employee_name(struct employee *employee_pointer, char new_name[80]);

#endif

type.h

Code:

#ifndef TYPE_H
#define TYPE_H

struct employee 
{
    char name[80];
    int age;
    char  address[256];
};

extern struct employee *eptr;

#endif

errors

Code:

main.C: In function ‘int main()’:
main.C:9: warning: deprecated conversion from string constant to ‘char*’
main.C:10: error: invalid application of ‘sizeof’ to incomplete type ‘employee’ 
main.C:10: error: invalid conversion from ‘void*’ to ‘employee*’
main.C:13: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:14: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:15: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:16: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:17: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:18: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’
main.C:19: error: invalid use of incomplete type ‘struct employee’
functions.h:4: error: forward declaration of ‘struct employee’

Yikes. My best guess would be that you're not compiling it right.

#1.

Code:

char *strdup_func(char *instr)
{
    char *outstr;
    if (!instr)
    {
        fprintf(stderr, "strdup: FATAL - NULL argument!\n");
        return(NULL);
    }
    
    outstr = (char *) malloc(sizeof(char) * (strlen(instr)+1) );

    ...

char *substrg(char *first_string, int start, int numchars)
{
    char *p;
	
    int count = 0, length = 0;
	
    length = strlen(first_string);
	
    if(start > length || length < 2 || start < 1)
    {
        return (NULL);
    }
	
    p = (char *) malloc(sizeof(char) * (numchars+1));

    ...

char *reverse_string(char *string)
{
    char *p;
    int slen = 0, count = 0;
    slen = strlen(string);
    p = (char *) malloc(sizeof(char) * (slen+1));
    ...

Casting the return value from the malloc call should be avoided. The function returns a void * and that should be converted safely to char *. Also, sizeof(char) is guaranteed to be 1 so multiplying anything by 1 does not change its value and that bit of code is therefore redundant. Those three lines should simply be:

Code:

outstr = malloc(strlen(instr)+1);

...

p = malloc(numchars+1);

...

p = malloc(slen+1);

#2 - Again with those same 3 functions:

Code:

char *strdup_func(char *instr);
char *substrg(char *first_string, int start, int numchars);
char *reverse_string(char *string);

None of those functions change the char* argument passed into them. For the sake of const correctness, they should probably be declared const:

Code:

char *strdup_func(const char *instr);
char *substrg(const char *first_string, int start, int numchars);
char *reverse_string(const char *string);

#3 You've called malloc in those 3 functions but there is nowhere in your program where you then call free to release that memory. This should be done just prior to exiting the program.



#4 Though you check for bad allocation in the strdup_func function, you fail to do so in the other 2 functions that call malloc.


#5

Originally Posted by mherald81

I keep getting this warning for three lines, assignment makes pointer from integer without a cast.

That usually occurs because the compiler doesn't have a definition/declaration of the function available at the point where the warning is issued. That is, the compiler doesn't know what the strdup_func looks like (most likely because the header hasn't been included prior to that point that does declare/define it). When this happens, it assumes a return type of int for strdup_func and then sees you are assigning this int to a char* and issues the warning you mention. This issue is usually fixed by properly including the necessary header. Post all your new code so we can see what's up.