Um mit mplayer Screenshots eines laufenden Videos zu erstellen, fügt man folgende Zeile in ~/.mplayer/config ein:

vf-add=screenshot

Jetzt können Screenshots mit s erstellt werden. Sie werden im Arbeitsverzeichnis gespeichert.

Output bei erfolgreicher Aktion:

*** screenshot 'shot0001.png' ***

Bei mehreren header-Dateien die sich untereinander referenzieren und einem Hauptprogramm dass beide inkludiert kann es zu Fehleren wie diesen kommen:

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

Beispielprogramm für verkettete Listen / stacks: Ein Programm, das beliebig viele Punkte einlesen und in einer verketteten Liste abspeichert. Beim Aufruf hat der Benutzer die Wahl neue Punkte einzugeben oder die bisherigen ausgeben zu lassen (in dem Fall werden sie auch aus dem stack gelöscht). Der stack soll/darf ausschließlich über die Funktionen pop() und push() bearbeitet werden.

/**
 * 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;
}

Mit folgendem Befehl kann man mit 7zip split archives erstellen:

7z a -v5M test.7z foo1/

Erstellt 5MB große Archive aus dem Ordner foo1/

Aufgabenstellung:
Der Benutzer soll 3 Punkte (bestehend aus je 3 Koordinaten) eingeben können und bekommt anschließend die Fläche dieses Dreiecks im Raum. Dies ist eine Erweiterung der Aufgabe Länge einer Strecke im Raum berechnen.

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;
}

Aufgabenstellung:
2 Punkte (bestehend aus 3 Koordinaten) sollen vom Benutzer eingegeben werden können. Daraus soll dann die Länge einer Strecke im Raum berechnet werden.
Die Formel:

/**
 * 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;
}

Tolle Übungsaufgabe in C: Ein Programm das die Länge eines angegebenen Strings, den Buchstaben mit den höchsten und den Buchstaben mit den niedrigsten ASCII-Wert zurückgibt. Die Funktion dafür soll aber nur die Länge des Strings als Rückgabewert liefern – der Rest soll über Pointer gemacht werden.

/***********************
 * 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;
}

Pidgin ist freie Software welche man unter http://pidgin.im/download/ herunterladen kann. Sie unterstützt mehrere Protokolle, so dass man z.B. mit seinem Jabber- und ICQ-Account gleichzeit online sein kann.

Ein Mal installiert kann man mit folgenden Schritten einen Jabber Account erstellen (Grund 1, Grund 2):

Hier auf “Konten” -> “Konten verwalten”

Hier auf “Hinzufügen”

Hier gewünschten Benutzernamen, Domain (z.B. jabber.org oder jaber.ccc.de), Ressource (kann z.B. auch “Work” sein) und ein Passwort. Den Haken ganz unten bei “Dieses neue Konto auf dem Server anlegen” nicht vergessen.

Danach steht einer Nutzung von Jabber nichts mehr im Weg.

Update:
Die Registrierung auf jabber.org ist durch Pidgin nicht mehr möglich. Einen Account kann man sich aber hier anlegen: http://register.jabber.org/

Tolle Übungsaufgabe in C: Ein Programm (bestehend aus 3 Dateien) das prüft, ob der eingegebene String ein Palindrom ist. Zudem soll das Programm auch Palindrome erkennen, die Leerzeichen enthalten und Groß- bzw. Kleinschreibung nicht unterscheidet.

/**
 * 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 *);

Mit diesem Befehl kann man alle Suchergebnisse unmittelbar löschen:

# löscht alle SVN Dateien aus dem aktuellen Verzeichnis
find . -type d -name ".svn" -exec rm -r {} \;