media.h:15: Fehler: Redefinition von »class Media«
media.h:16: Fehler: vorherige Definition von »class Media«

Um diese Fehler zu vermeiden kann man sich einer Präprozessorabfrage bedienen. In diesem Fall heisst die Datei container.h:

#ifndef CONTAINER_H
#define CONTAINER_H

// code

#endif

Eclipse etc. machen das automatisch, aber es soll ja noch Leute geben die vim benutzen. ;-)

Prevent multiple definitions in header files

/**
 * Datei: pointStack.c
 * Funktionen vom Stack Programm
 *
 * Rainer Hihn
 */

#include "pointStack.h"

/**
 * globale Variable, die auf das
 * oberste Element des Stacks zeigt
 */
STACK_POINT_PTR stackTop = NULL;

void push(POINT pushPoint)
{
    /**
     * temporaere Variable
     */
    STACK_POINT_PTR stackPoint = (STACK_POINT_PTR) malloc(sizeof(STACK_POINT));

    /**
     * debugging
     * printf("%d \n", stackPoint);
     */

    /**
     * Abbruchbedingung, falls zu wenig Speicher zur Verfuegung steht
     */
    if(stackPoint == NULL)
    {
        printf("nicht genug Speicher zur Verfuegung ... Ende \n");
        exit(1);
    }

    /*
     * Punnkt speichern und
     * stackTop auf den aktuellen Wert setzen
     */
    stackPoint->p = pushPoint;
    stackPoint->next = stackTop;
    stackTop = stackPoint;

    return;
}

POINT pop()
{
    /**
     * stackTop und nextStackTop
     * zwischenspeichern
     */
    STACK_POINT firstStackPoint = *stackTop;

    /**
     * Speicher vom obersten
     * Stack-Element freigeben
     */

    /**
     * debugging
     * printf("%d \n", stackTop);
     */
    free(stackTop);

    /**
     * stackTop auf das ehemals
     * zweite Element des Stacks setzen
     */
    stackTop = firstStackPoint.next;

    /**
     * Punkte vom ehemals ersten Element
     * zurueckgeben
     */
    return firstStackPoint.p;
}

int isEmpty()
{
    /**
     * wenn next auf NULL zeigt
     * dann ist dies das letzte Element
     * des Stacks
     * und es wird '1' zurueckgegeben
     */
    if(stackTop == NULL)
    {
        return 1;
    }
    else {
        return 0;
    }
}

void printStackElement(POINT aPoint)
{
    printf("Punkt x: %f, Punkt y: %f, Punkt z: %f \n", aPoint.rX, aPoint.rY, aPoint.rZ);
    return;
}

/**
 * Datei: pointStack.h
 * Headerdatei fuer Stack Programm
 *
 * Rainer Hihn
 */

#include 
#include 

/*
 * structs
 */

/*
 * struct fuer die Koordinaten
 */
struct point
{
    float rX;
    float rY;
    float rZ;
};
typedef struct point POINT;

struct stackPoint
{
    POINT p;
    struct stackPoint *next;
};
typedef struct stackPoint STACK_POINT;
typedef STACK_POINT *STACK_POINT_PTR;

/*
 * Funktionen
 */
void push(POINT pushPoint);
POINT pop();
int isEmpty();
void printStackElement(POINT aPoint);

/***********************
 * Datei: stackmain.c
 * Speichern einer Menge von Punkten
 *
 * Rainer Hihn
 */

#include "pointStack.h"

void exit(int);

POINT readPoint()
{
    POINT userPoint;

    printf("Bitte x-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rX);
    printf("Bitte y-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rY);
    printf("Bitte z-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rZ);

    return userPoint;
}

int main(void)
{
    /**
     * Variablendeklaration
     */
    char cCmd;

    printf("’p’ fuer Punkt eingeben, ’q’ fuer Ausgabe: \n");

    while(1)
    {

        scanf("%c", &cCmd);

        if(cCmd == 'p')
        {
            push(readPoint());
            printf("’p’ fuer Punkt eingeben, ’q’ fuer Ausgabe: \n");
        }

        if(cCmd == 'q')
        {
            while(!isEmpty())
            {
                printStackElement(pop());
            }
            break;
        }
    }

    return 0;
}

Benötigte Formeln:

/**
 * Headerdatei fuer Palindrom
 * Funktiondeklarierung
 *
 * Rainer Hihn
 */

#include 
#include


/*
 * functions
 */
struct point readPoint();
float distance(struct point point1, struct point point2);
float areaTrinagle(struct point point1, struct point point2, struct point point3);

/*
 * structs
 */
struct point
{
    float rX;
    float rY;
    float rZ;
};

/**
 * Funktionen von 'Laenge einer Strecke im Raum'
 *
 * Rainer Hihn
 */

#include "strecke.h"

/**
 * x-, y- und z-Koordianten einlesen
 */
struct point readPoint()
{
    struct point userPoint;

    printf("Bitte x-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rX);
    printf("Bitte y-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rY);
    printf("Bitte z-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rZ);

    return userPoint;
}

/**
 * Distanz zwischen 2 Punkten berechnen
 */
float distance(struct point point1, struct point point2)
{
    float rNewX = 0;
    float rNewY = 0;
    float rNewZ = 0;
    float rDistance = 0;

    rNewX = point1.rX - point2.rX;
    rNewY = point1.rY - point2.rY;
    rNewZ = point1.rZ - point2.rZ;

    rDistance = sqrt((rNewX * rNewX) + (rNewY * rNewY) + (rNewZ * rNewZ));

    return rDistance;
}

/**
 * Flaeche eines Dreicks berechnen
 * die Seitenlaengen werden mittles distance()
 * berechnet
 */
float areaTrinagle(struct point point1, struct point point2, struct point point3)
{
    float rA = 0; /* Seitenlaenge A */
    float rB = 0; /* Seitenlaenge A */
    float rC = 0; /* Seitenlaenge A */
    float rS = 0; /* halber Umfang */

    rA = distance(point1, point2);
    rB = distance(point2, point3);
    rC = distance(point3, point1);

    rS = (rA + rB + rC)/2;

    return sqrt(rS * (rS - rA) * (rS - rB) * (rS - rC));
}

/***********************
 * Laenge einer Strecke im Raum
 *
 * Rainer Hihn
 */

#include "strecke.h"

int main(void)
{
    /**
     * Variablendeklaration
     */
    struct point firstPoint;
    struct point secondPoint;
    struct point thirdPoint;

    printf("Entfernung berechnen \n");

    /**
     * einlesen der 3 Punkte
     */
    firstPoint = readPoint();
    secondPoint = readPoint();
    thirdPoint = readPoint();

    printf("Die Flaeche des Dreiecks betraegt %f \n", areaTrinagle(firstPoint, secondPoint, thirdPoint));

    return 0;
}

/**
 * Headerdatei fuer Streckenberechnung
 * Funktiondeklarierung
 *
 * Rainer Hihn
 */

#include 
#include


/*
 * functions
 */
struct point readPoint();
float distance(struct point point1, struct point point2);

/*
 * structs
 */
struct point
{
    float rX;
    float rY;
    float rZ;
};

/**
 * Funktionen von 'Laenge einer Strecke im Raum'
 *
 * Rainer Hihn
 */

#include "strecke.h"

struct point readPoint()
{
    struct point userPoint;

    printf("Bitte x-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rX);
    printf("Bitte y-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rY);
    printf("Bitte z-Koordinate eingeben \n");
    scanf("%62f", &userPoint.rZ);

    return userPoint;
}

float distance(struct point point1, struct point point2)
{
    float rNewX = 0;
    float rNewY = 0;
    float rNewZ = 0;
    float rDistance = 0;

    rNewX = point1.rX - point2.rX;
    rNewY = point1.rY - point2.rY;
    rNewZ = point1.rZ - point2.rZ;

    rDistance = sqrt((rNewX * rNewX) + (rNewY * rNewY) + (rNewZ * rNewZ));

    return rDistance;
}

 * Laenge einer Strecke im Raum
 *
 * Rainer Hihn
 */

#include "strecke.h"

int main(void)
{
    /**
     * Variablendeklaration
     */
    struct point firstPoint;
    struct point secondPoint;

    printf("Entfernung berechnen \n");

    firstPoint = readPoint();
    secondPoint = readPoint();

    printf("Die Entfernung von Punkt 1 nach Punkt 2 ist: %f \n", distance(firstPoint, secondPoint));

    return 0;
}

/***********************
 * Stringstats
 *
 * Rainer Hihn
 */

#include 
#define LENGTH 64

/*
 * Funktion deklarieren
 */
int stringstats(char[], char *, char *);

int main(void)
{
    /**
     * Variablendeklaration
     */
    char cString[LENGTH] = {0};
    int iLength = 0;
    char cGroesster = 0;
    char cKleinster = 0;

    while(1)
    {
       /**
         * Benutzereingabe String
         */
        printf("Bitte einen String eingeben ('q' fuer Beenden) \n");
        scanf("%62s", &cString);

        /**
         * Abbruchbedingung pruefen
         */
        if(cString[0] == 'q' && cString[1] == '\0')
        {
            break;
        }

        /**
         * Funktion stringstats aufrufen
         */
        iLength = stringstats(cString, &cGroesster, &cKleinster);

        printf("Laenge: %i \n", iLength);
        printf("Kleinster Buchstabe: %c \n", cKleinster);
        printf("Groesster Buchstabe: %c \n\n", cGroesster);
    }

    return 0;
}

/**
 * Funktionen um Werte eines
 * Strings zu berechnen
 */

#include 

int stringstats(char sString[], char* cGroesster, char* cKleinster)
{
    /**
     * Variablendeklaration
     */
    int iLength = 0;
    int i = 0;
    *cKleinster = sString[0];
    *cGroesster = sString[0];

    while(sString[iLength] != '\0')
    {
        iLength++;

    }

    for(i = 0; i <= iLength-1; i++)
    {
        if(sString[i] < *cKleinster)
        {
            *cKleinster = sString[i];
        }

        if(sString[i] > *cGroesster)
        {
            *cGroesster = sString[i];
        }
    }

    return iLength;
}

/**
 * Funktionen des Palindrom-Programms
 *
 * Rainer Hihn
 */

#include 

/**
 * ermittelt die Laenge eines Strings
 */
int lengthOfString(char cWord[])
{
    int i = 0;

    /**
     * solang das Ende nicht erreicht ist
     * wird der Wert i um 1 erhöht
     */
    while(cWord[i] != '\0')
    {
        i++;
    }

    return i;
}

/**
 * prueft, ob der angegebe String ein Palindrom ist
 */
int isPalindrom(char cWord[])
{
    int i = 0;
    int length = lengthOfString(cWord);

    for(i = 0; i <= (length-1); i++)
    {
        /**
         * vergleiche ersten und letzten, zweiten und vorletzten etc Buchstaben
         */
        if(cWord[i] != cWord[((length-1)-i)])
        {
            /**
             * vergleiche Gross- und Kleinschreibung
             */
            if(cWord[i]+32 != cWord[((length-1)-i)] && cWord[i]-32 != cWord[((length-1)-i)])
            {
                return 0;
            }
        }
    }

    return 1;
}

/***********************
 * Palindromtest
 *
 * Rainer Hihn
 */

#include "palindromfun.h"
#define LENGTH 63

int main(void)
{
    /**
     * Variablendeklaration
     */
    char cWord[LENGTH] = {0};
    char cWordWork[LENGTH] = {0};
    int i = 0;
    int j = 0;

    /**
     * Benutzereingabe String
     */
    printf("Bitte ein Wort eingeben \n");
    scanf("%62[^\n]s", cWord);

    for(i = 0; i <= LENGTH-1; i++)
    {
        if(cWord[i] != ' ')
        {
            cWordWork[j] = cWord[i];
            j++;
        }
    }

    if(isPalindrom(cWordWork))
    {
        printf("%s ist ein Palindrom \n", cWord);
    }
    else {
         printf("%s ist kein Palindrom \n", cWord);
   }

    return 0;
}

/**
 * Headerdatei fuer Palindrom
 * Funktiondeklarierung
 *
 * Rainer Hihn
 */

#include 

int isPalindrom(char *);
int lengthOfString(char *);

/***********************
 * Ein einfacher Taschenrechner
 *
 * Rainer Hihn
 */

#include 

void exit(int);

float calculate(char optr, float opr1, float opr2)
{
    float rErg = 0;

    switch(optr) {
        /**
         * addieren
         */
        case '+':
            rErg = opr1 + opr2;
            break;
        /**
         * subtrahieren
         */
        case '-':
            rErg = opr1 - opr2;
            break;
        /**
         * multiplizieren
         */
        case '*':
            rErg = opr1 * opr2;
            break;
        /**
         * dividieren
         */
        case '/':
            rErg = opr1 / opr2;
            break;
        /**
         * Wenn kein erlaubter
         * Operator eingegeben wurde
         */
        default:
            printf("Falscher Operator \n");
            exit(1);
    }

    return rErg;
}

int main(void)
{
    /**
     * Variablendeklaration
     */
    char cOptr;
    float fOpr1;
    float fOpr2;
    float fErg;

    while(1)
    {
        printf("Eingabe: Operator  Operand1  Operand2  \n");

        /**
         * Benutzereingabe Operator
         */
        printf("Bitte Eingabe Operator \n");
        scanf(" %c", &cOptr);

        /**
         * Programm wird beendet wenn
         * 'q' eingeben wird
         */
        if(cOptr == 'q')
        {
            break;
        }

        /**
         * Benutzereingabe Operand 1
         */
        printf("Bitte Eingabe Operand1: \n");
        scanf(" %f", &fOpr1);
        /**
         * Benutzereingabe Operand 2
         */
        printf("Bitte Eingabe Operand2: \n");
        scanf(" %f", &fOpr2);

        if(cOptr == '/' && fOpr2 == 0)
        {
            printf("ehm ... nein? \n");
            break;
        }

        /**
         * Ergebnis berechnen und ausgeben
         */
        fErg = calculate(cOptr, fOpr1, fOpr2);
        printf("%f %c %f = %f \n\n", fOpr1, cOptr, fOpr2, fErg);
    }

    return 0;
}

/***********************
 * Umrechnung Dezimalzahl
 * nach Dualzahl
 *
 * Rainer Hihn
 */

#include 

int main(void)
{
    /**
     * Variablendeklaration
     */
    int iDezi = 0;
    int iDual[16] = {0};
    int i = 0;
    int iErg = 0;
    int iRest = 0;

    /**
     * Einlesen der Dezimalzahl
     */
    printf("Geben Sie eine Dezimalzahl ein: \n");
    scanf("%i", &iDezi);
    printf("\n");

    /**
     * Pruefen ob die Dezimalzahl
     * groesser als 16 bit ist
     */
    if(iDezi > 65536)
    {
        printf("Geben Sie eine Dezimalzahl ein die kleiner als 65.536 ist \n");
    }
    else{
        iErg = iDezi;
        i = 0;

        while(iErg > 0)
        {
            if(iErg % 2 == 0)
            {
                iDual[i] = 0;
            }
            else {
                iDual[i] = 1;
            }

            iErg = iErg / 2;
            i++;
        }

        /**
         * Ausgabe der Dualzahl
         */

        i = 15;
        for(i = 15; i >= 0; i--)
        {
            printf("%i", iDual[i]);
        }
        printf("\n");
    }

    return 0;
}

/***********************
 * Ascii Tabelle
 *
 * Rainer Hihn
 */

#include 

int main(void)
{
    int Start   = 32;
    int Ende    = 55;
    int i       = 0;
    int j       = 0;

    for(i = Start; i <= Ende; i++)
    {
        for(j = 0; j <= 3; j++)
        {
            printf("%i ", i+(j*24));
            printf("%c\t", i+(j*24));
        }
        printf("\n");
    }

}

1       2       3
2       4       6
3       6       9
4       8       12

Lösungsvorschlag mit einer for-Schleife:

/*
 * Multiplikationstabelle mit for-Schleife
 *
 * by Rainer Hihn
 */

#include 

int main(void) {
	/*
	 * vertical and horizontal limit
	 */
	int hlimit;
	int vlimit;

	scanf("%d", &hlimit);
	scanf("%d", &vlimit);

	/*
	 * for loop vars
	 */
	int i;
	int j;

	for(i = 1; i <= vlimit; i++) {
		for(j = 1; j <= hlimit; j++) {
			printf("%d\t", i*j);
		}
		printf("\n");
	}	

	printf("\n");

	return 0;
}

while-Schleife:

/*
 * Multiplikationstabelle mit while-Schleife
 *
 * by Rainer Hihn
 */

#include 

int main(void) {
	/*
	 * vertical and horizontal limit
	 */
	int hlimit;
	int vlimit;

	scanf("%d", &hlimit);
	scanf("%d", &vlimit);

	 /*
	  * while loop vars
	  */
	 int i = 1;
	 int j = 1;

	while(i <= vlimit) {
		while(j <= hlimit) {
			printf("%d\t", i*j);
			j++;
		}
		j = 1;
		i++;
		printf("\n");
	}	

	printf("\n");

	return 0;
}