Funktion Datentyp unabhängig machen

Gimmli

hi,

Wie schaffe ich es eine Funktion datentyp unabhängig zu machen ich hab mir den prototypen von qsort angesehn allerdings verstehe ich nicht wie es intern arbeitet....

vl kann mir wer dabei helfen diese funk typenlos umzuschreiben:

void setze_array_auf_null(int **matrix, int zeile, int spalte) {
	int j, i;
	for (j=0; j<zeile;j++) {
		for (i=0; i<spalte;i++) {
			matrix[j][i]=0;
		}
	}
}

ist eine primitive funktion die alle elemente in einem 2dim array auf 0 setzt...

müsste sonst für jeden datentyp eine eigene funktion schreiben wo sich nur der prototyp ändert...

mfg
Gimmli

CStoll

In C kannst du nur mit void* arbeiten und selber dafür sorgen, daß der Datentyp passt (wird aber auf die Dauer unangenehm).

In C++ hättest du Templates

Gimmli

Heist also es gibt nciht wriklich eine sinnvolle bzw einfache lösung heist also für jeden datentyp ne funk schreiben ! ^^ juhuuu

Da ist mir grad was durch den kopf geschossen kann man das nicht mit einer union realisieren?

CStoll

In C sieht's wohl so aus - entweder du schreibst eine Funktion für jeden Typ oder eine Funktion, die mit void-Zeigern hantiert (solange die Null in einem Datentyp aus binären Nullen besteht, könntest du mit memset() dein Verhalten nachbauen).

Oder du wechselst zu C++ - da hast du mit den Templates genau das, was du suchst - eine Familie von identisch aussehenden Funktionen, die sich nur im verwendeten Datentyp unterscheiden.

(PS: In C könntest du sowas mit Makros bauen, wenn du unbedingt willst)

supertux

CStoll schrieb:

In C kannst du nur mit void* arbeiten und selber dafür sorgen, daß der Datentyp passt (wird aber auf die Dauer unangenehm).

In C++ hättest du Templates

In C kann man auch Templates nachbilden, sind aber ein wenig stressig zu handhaben, aber manchmal musste ich sie schreiben.

edit: Upps, zu spät gelesen, dass du auf Makros hingewiesen hast

Gimmli

Dnake für dei antworten mal nachgooglen! ^^

Gimmli

hat wer n beispiel wie das mit den makros funkt?

CStoll

Ohne Garantie auf Korrektheit:

#define setze_array_auf_null(matrix, zeile, spalte) \
do {                                                \
    int j, i;                                       \
    for (j=0; j<zeile;j++) {                        \
        for (i=0; i<spalte;i++) {                   \
            matrix[j][i]=0;                         \
        }                                           \
    }                                               \
} while(0)

Gimmli

aha ok so is das gemeint DANKE!!!! jz komm ich weiter denke ich! ^^

supertux

Gimmli schrieb:

Dnake für dei antworten mal nachgooglen! ^^

Hier mal ein ganz kleines (und einfaches) Bsp:

/* File: fifo_template.h */

#ifndef FIFO_TEMPLATE_H
#define FIFO_TEMPLATE_H

#include <stdlib.h>

#define CREATE_FIFO_HEADER(qname, type)\
    struct qname {\
        struct qname *next;\
        struct qname *prev;\
        struct qname *tail;\
        type data;\
    };\
    int push_ ## qname (struct qname *fifo, type *data);\
    int top_ ## qname (struct qname *fifo, type **element);\
    int pop_ ## qname (struct qname **fifo);\
    void free_ ##qname (struct qname *fifo);

#define CREATE_FIFO_CODE(qname, type)\
    int push_ ## qname (struct qname *fifo, type *data)\
    {\
        struct qname *tmp;
        if(fifo == NULL) return 0;\
        tmp = malloc(sizeof(struct qname));\
        if(tmp == NULL) return 0;\
        memcpy(&tmp->data, data, sizeof(type));\
        tmp->next = NULL;\
        tmp->prev = fifo->tail;\
        fifo->tail->next = tmp;\
        fifo->tail = tmp;\
        return 1;\
    }\
    \
    int top_ ## qname (struct qname *fifo, type **element)\
    {\
        if(fifo == NULL){\
            element = NULL;\
            return 0;\
        }\
        \
        *element = &fifo->data;\
        return 1;\
    }

#define CREATE_FIFO_FIRST_NODE(qname,fifo,data) \
    do {\
        fifo = malloc(sizeof(struct qname));\
        if(fifo == NULL) break;\
        fifo->next = NULL;\
        fifo->tail = fifo;\
        fifo->prev = NULL;\
        memcpy(&fifo->data, data, sizeof(data));\
    } while(0);

#endif

die pop & free Funktionen als Übung für den Leser

/* File: fifo_int.h */

#ifndef FIFO_INT_H
#define FIFO_INT_H

#include "fifo_template.h"

CREATE_FIFO_HEADER(fifo_int, int)

#endif

/* File: fifo_int.c */

#include "fifo_int.h"

CREATE_FIFO_CODE(fifo_int, int)

/* FILE: main.c */

#include <stdio.h>
#include <stdlib.h>
#include "fifo_int.h"

int main(int argc, char **argv)
{
    int i,z;
    struct fifo_int *fifo;

    if(argc < 2) return 1;

    z = atoi(argv[1]);

    CREATE_FIFO_FIRST_NODE(fifo_int, fifo, z);

    if(fifo == NULL) return 1;

    for(i=2; i < argc; ++i)
    {
        z = atoi(argv[i]);
        push_fifo_int(fifo, &z);
    }

    ...

    free_fifo_int(fifo);

    return 0;
}

//edit: das einzige Problem, es ist ein wenig beschränkt mit den Datentypen. Arrays und Zeiger werden nicht so sehr akzeptiert, aber für native Datentypen und structs ganz gut geeignet.

Gimmli

Hab für mich eine Einfachere (universellere) Lösung gefunden weis ned ob ich es jz so gut erklären kann das ihr es versteht aber ich mache es so:

ich habe mir eine union geschrieben siehe hier:

union zeiger{
  char   **c;
  int    **i;
  double **d;
  float  **f;
}hilfszeiger;

und ich übergebe jeder funktion einen string wo der datentyp drinnen steht prinzibiel könnte man da ncoh n enum draus machen

und prüfe dann einfach mit einer if else verkettung welcher zeiger jetz zum einsatz kommt und mache mit dem dann weiter...

hoffe es war verständlich