takkaria/notes.md

## notes.md

      
    Raw
  

              notes.md
            
          
    I understand the intent of what you were doing, which was to return an array from ziffern_extrahieren() and copy the results of that array into the array in is_armstrong_number().  I'll point out the mistakes in what you wrote and explain how you do this in C.
Compiler errors

int *ziffern_extrahieren(int candidate, int laenge) {
	int *ziffern = malloc(...);
	...
	return *ziffern;
}
Here when you write return *ziffern you are returning what ziffern points to.  The way C works, *ziffern is equivalent to writing ziffern[0].  So you're not returning an int *, you're returning an int.  You'd want to write just return ziffern.
int *ergebnis = malloc(..);
*ergebnis = ziffern_extrahieren(...);
So here, you have written is "set what ergebnis points to (ergebnis[0]) to the return value of ziffern_extrahieren()".  But you can't do this, because the type of *ergebnis is int, and the return type of ziffern_extrahieren() is int *.
So now you see why people stopped using C!
Different approaches

1. memcpy
In C the way you write "take this bit of memory and copy it over to this other bit of memory" (which is the only way you can copy arrays in C apart from iterating over each element) is using memcpy():
void *memcpy(void *destination, void *source, size_t length);
so
int *result = ziffern_extrahieren();
memcpy(ergebnis, result, laenge * sizeof int);
Will fill ergebnis with the result of ziffern_extrahieren().  In full:
// Note this version doesn't return a value
int *ziffern_extrahieren(int candidate, int laenge) {
	int *ziffern = malloc(laenge * sizeof int);
	int power = 1;
	for (i = laenge; i > 0; i--) {
		ziffern[i] = (candidate % (10 * power)) / power;
		power *= 10;
	}
	return ziffern;
}

bool is_armstrong_number(int candidate) {
	int laenge = laenge_berechnen(candidate);
	int *ergebnis = malloc(laenge * sizeof int);
	int *result = ziffern_extrahieren(candidate, ergebnis, length)
	memcpy(ergebnis, result, laenge * sizeof int);
	...
	return true;
}
There are two problems here still though.  The first is that the above code has two memory leaks.  Once memory is allocated, you need to free it.  This can be fixed by adding in:
	free(result);
	free(ergebnis);
before the final return.
The second is more conceptual, and it's that you're allocating two different bits of memory to contain the same data and copying from one to the other.  In C people generally avoid that using one of the other three approaches...
2. Allocate memory in is_armstrong_number() and pass it to ziffern_extrahieren() to be filled
This is a neater way of doing things.  It's nice because the malloc() and the free() happen in the same function, so it's easier not to have a memory leak.
// Note this version doesn't return a value
void ziffern_extrahieren(int candidate, int *ziffern, int laenge) {
	int power = 1;
	for (i = laenge; i > 0; i--) {
		ziffern[i] = (candidate % (10 * power)) / power;
		power *= 10;
	}
}

bool is_armstrong_number(int candidate) {
	int laenge = laenge_berechnen(candidate);
	int *ergebnis = malloc(laenge * sizeof int);
	ziffern_extrahieren(candidate, ergebnis, length)
	...

	// Make sure you call free() before returning or you have a memory leak.
	free(ergebnis);
	return true;
}
3. Use variable length arrays
I don't know what C compiler you are using, but C99 compilers let you allocate memory on the stack without using malloc.  If you're using Microsoft's compiler then you can't do this because they still don't support a 20 year old standard, but anywhere else the following is valid C!
// ziffern_extrahieren is the same as above

bool is_armstrong_number(int candidate) {
	int laenge = laenge_berechnen(candidate);
	int ergebnis[laenge];
	ziffern_extrahieren(candidate, ergebnis, length)
	...
	return true;
}
This is the difference between heap allocation and stack allocation:


Heap allocation (asking the OS for some memory please) means you're taking over the limited memory management that the C compiler does and asking for bits of memory yourself - and freeing them later (or fogetting to).


Stack allocation is what you get when you write variable declarations in your code - the C compiler allocates memory for these and frees it again when it's out of scope.


4. Allocate the memory in ziffern_extrahieren() and return it to is_armstrong_number()
This is like number 2.
int *ziffern_extrahieren(int candidate, int laenge) {
	int *ziffern = malloc(laenge * sizeof int);
	int power = 1;
	for (i = laenge; i > 0; i--) {
		ziffern[i] = (candidate % (10 * power)) / power;
		power *= 10;
	}
	return ziffern;
}

bool is_armstrong_number(int candidate) {
	int laenge = laenge_berechnen(candidate);
	int *ergebnis = ziffern_extrahieren(candidate, laenge);
	...
	free(ergebnis);
	return true;
}
This is sort of nicer than 1 because the function that needs the memory creates it, which means that you can't accidentally allocate the wrong amount of memory to pass into the function.  But it does mean the function where the memory is allocated is not the same function as when it needs to be freed, which makes it easier to mess up and cause memory leaks.
Location	Value	Name
0x7eb77140	0x7eb77144	ppp
0x7eb77144	0x7eb77148	pp
0x7eb77148	0x7eb7714c	p
0x7eb7714c	0xff	v