Summe der Elemente eines Arrays von einem beliebigen ganzzahligen Datentyp

volkard schrieb:

void sum(void* result, void const *array, size_t arrCount, size_t elemSize, void(*pAddFunc)(void* r,void const* a,void const* b));

Naja, das sieht schlimmer aus als es ist.

void accumulate(const void *base, size_t nmemb, size_t size,
	 void* init, void (*acc)(void *, const void *)){
  register char *base_ptr = (char *) base;
  while(nmemb--){
    acc(init, base_ptr);
    base_ptr += size;
  }
}

void acc(void *x, const void *y){
  *(int *)x += *(int *)y;
}

void f(){
  int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
  size_t N = sizeof(arr) / sizeof(*arr);
  int result = 0;
  accumulate(arr, N, sizeof(*arr), &result, acc);
}

Für sowas wären die C11 type generic macros super.

It0101

Was besseres als void * und dann beim Aufsummieren ein entsprechender cast nach long long fällt mir dazu allerdings auch nicht ein. Eine unschöne Aufgabenstellung mit den Bordmitteln von C...

knivil

Generische Programmierung ist noch unhandlicher als in C++. Warum also? Definiere die Funktion, die du brauchst! Loesungen mittels void* etc. sind schlecht im Hinblick auf Performance, da sie alles an Typinfomationen wegschmeisst, die der Compiler verwerten koennte.

It0101

Mir stellt sich die Frage, welche Anwendungsfälle es für eine "Addition mit unbestimmtem Typ" gibt? Mir ist das noch nicht untergekommmen Vielleicht eine mathematische Bibliothek...

Vielleicht sollte man auch mal hinterfragen, warum der TE das braucht. Im C++-Bereich hätte man dem TE zunächst einmal konzeptionelle Fehler unterstellt, mal abgesehen davon, dass die hier vorgegebene Aufgabe natürlich in C++ kein Problem darstellt

Der Typ ist ja nicht unbestimmt, sondern soll variabel sein

Ein Anwendungsfälle wäre z.B. in der Messdatenverarbeitung.
Du bekommst von Messgeräten die Daten in verschiedenen Typen. z.B vom ADC als 16-Bit (auch wenn er nur 10-Bit Auflösung hat) oder Längenmessung mit 32-Bit oder ...

Dann hast du nur eine Funktion die die Berechnung macht.

Wutz

Für gängige int-Bytegrößen baust du dir für den Elementzugriff ein Makro und fertig.

#define iptr(i,a,n) (8==i?n[(long long*)a]:4==i?n[(long*)a]:2==i?n[(short*)a]:n[(char*)a])

long long summe(const void *a,size_t s,size_t n)
{
  long long r=0;
  assert( (s&15) == s );
  while(n--)
    r+=iptr(s,a,n);
  return r;
}

int main()
{
  char  a1[3]={-1,0,+4};
  short a2[3]={-4,0,+1};
  long  a3[3]={-3,0,+1};
  long long a4[3]={-1,0,+3};

  long long r = summe(a1,sizeof*a1,3)+summe(a2,sizeof*a2,3)+summe(a3,sizeof*a3,3)+summe(a4,sizeof*a4,3);

  assert( r == 0 );
}

Wutz schrieb:

#define iptr(i,a,n) (8==i?n[(long long*)a]:4==i?n[(long*)a]:2==i?n[(short*)a]:n[(char*)a])

das ist ein stümperhaftes müll makro mit undefinded behaviour.

Ist ja mal total panne die Typentscheidung in der Schleife zu machen.

CJosef

#define GENERIC_SUMMATION(arrayptr, type, count, sum)  { \
															int i; \
															sum = 0; \
															for ( i = 0; i < count; i++ ) \
																sum += *((type*)arrayptr + i); \
														}
int main ( void )
{
	int array[] = {1,2,3}, sum;
	GENERIC_SUMMATION (array, int, sizeof(array)/sizeof(array[0]), sum);
	printf ( "%d", sum );
	return 0;
}