I love C so much, and I really want to hate sepples, but I can't help but think that generic programming in C is shit! Macros are no good for generic data structures, as they are clunky and blow out code size, nor are void pointers, as you need to allocate separate memory just to store an integer (don't stuff ints into pointers; zeros won't work on architectures where the null pointer constant is non-zero). I really want to write my data structure library in sepples, where templates allow type genericism without issue. What should I do, /prague/; what should I do?!
>>3
There is no ``function call stack'' in C so you are wrong right from the start, and in any case, if you are worried about a little bit of macro replacement you shouldn't be using C in the first place. (You do know how #include works, right?)
int main() {
IntVec x = IntVecCreate();
for(int i = 0; i < 3; i++) IntVecPush(&x, i);
for(int i = 0; i < 3; i++) printf("%d ", IntVecPop(&x));
printf("\n");
}
>>51
No, please explain to me what he means when he's talking about a stack in C, please do, because I can't find it mentioned anywhere in C89, C99 or C11.
Name:
Anonymous2012-01-12 14:35
>>3,40,46
The C standard does not describe or mention a "stack." In many implementations, the activation record, arguments, and local variables are stored in different regions of memory or registers. The System/360 (S/370, S/390, and System z) uses a linked list of activation records allocated using GETMAIN and separate memory regions for the argument list and local variables, also allocated using GETMAIN. Similarly, the ARM allows "chunked stacks" where each activation record is part of a linked list. The VAX uses a contiguous stack for return addresses, but also has CALLG which is a standard call where the argument list can be anywhere in memory. Many RISCs pass arguments in registers and store the return address in a register, so they are able to complete a function call without even touching a stack. Other machines may use separate stacks for return addresses, arguments, and local variables, and may further break them down depending on whether these items are integers, floating-point, or pointers. Some small architectures like PICs may use static variables for all functions that are determined at compile time not to be recursive, allowing the fixed-size stack to be conserved for storing return addresses without violating the standard.
Name:
Anonymous2012-01-12 15:04
>>40
C is a high level language, it has no notion or knowledge of a call stack.
Name:
Anonymous2012-01-12 15:23
>>54 Many RISCs pass arguments in registers and store the return address in a register, so they are able to complete a function call without even touching a stack.
Don't forget Itanium, it does (did?) all that and more.
Some small architectures like PICs may use static variables for all functions that are determined at compile time not to be recursive, allowing the fixed-size stack to be conserved for storing return addresses without violating the standard.
That's not really about an architecture, only about compiler. Keil Microvision did that for 8051, but seamlessly switched to compiling functions as reentrant (all locals on stack) if necessary. I sometimes wonder why none of the major x86 compilers do that, if you don't count inlining as the logical conclusion of this approach.
But a class isn't a struct. It's a struct that defaults members to be private. And C++ structs are better than C structs. They have an implicit typedef and can have methods as well as member variables.
Why shouldn't one just use C++ instead of tossing around shitty C hacks?
If you are still here OP I'd be interested in your thoughts on the technique in >>42 considering it does not duplicate code for every use of the data structure.
(Post truncated.) is an inherently sinful message.
End the delusions. Open your chakras.
Name:
Anonymous2012-01-13 3:20
>>59
Still a disgusting abuse of preprocessor macros. It's hardly elegant.
Name:
Anonymous2012-01-13 5:57
>>59
Well I'm not OP but _LStruct is a reserved identifier, you managed to make it O(n) even though you're only defining two operations on it which you named push and pop and are commonly used for stacks, you never check malloc or realloc for failing so it will probably just segfault after a while considering you're just allocating double the amount of memory every time and you never give any option to create it a capacity of less than 128 elements.
>>66
You are an idiot. It's a proof of concept, and you didn't bring a single conceptual issue to bare. Why don't you go and argue about the color of some bike sheds?
C11 has improved generic support for the preprocessor.
Check out GCC 4.7 or Clang 3.1 nightly snapshots.
Name:
Anonymous2012-01-13 21:44
>>73
What is your point? You have to know all the types you want to generate functions for before you create the generic selection macro so it does nothing to aid us in this situation.
Name:
Anonymous2012-01-13 22:16
>>40
Actually, I guess what >>39-san is saying is that nowhere in the standard that defines C there is any mention of a "function call stack". It is usually implemented that way but that is not mandatory. Officially, C does not have a stack.
In fact, in some architectures, it is not even an advantage for it to be implemented with them.
Name:
Anonymous2012-01-14 3:18
>>1 architectures where the null pointer constant is non-zero
>>79
If you compare the logical value of pointers to a constant integer zero, you should be fine. But if you use memcmp or do union or casting tricks to compare the bit pattern of the pointer to the bit pattern of an integer with a value of zero, it is not guaranteed to be zero. #include <assert.h>
int main(void) {
union {
void *p;
int i;
} u;
u.p = 0;
void *p = 0;
int i = 0;
assert(p == u.p); /* true */
assert(p == 0); /* true */
assert(u.p == 0); /* true */
//assert((int)p == i); /* not guaranteed */
//assert((int)u.p == u.i); /* not guaranteed */
//assert(p == (void *)i); /* not guaranteed */
//assert(u.p == (void *)u.i); /* not guaranteed */
//assert(memcmp(&u.i, &i, sizeof(int)); /* not guaranteed */
}
Generic programming in C
Back in my time, when men were men, we simply used void pointers and an enum that indicated the real type of the pointer if needed.
Name:
Anonymous2012-01-14 6:07
>>81
Back in my time, we used two unused lower bits of pointer to hold type.
A generic linked list that will contain anything you could think of. No macros! It assumes struct node has the strictest alignment.
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
// API
struct list;
struct list *make_list(size_t elem_size);
void *prepend(struct list *l);
void *append(struct list *l);
void *insert_after(struct list *l, void *node);
void *insert_before(struct list *l, void *node);
void *head(struct list *l);
void *tail(struct list *l);
void *next(void *node);
void *previous(void *node);
// implementation
struct list
{
size_t elem_size;
struct node head, tail;
};
struct node
{
struct node *prev, *next;
};
struct list *make_list(size_t elem_size)
{
struct list *l;
for (p = next(head(l)); p != tail(l); p = next(p)) {
printf("%s %d\n", p->name, p->age);
}
exit(EXIT_SUCCESS);
}
I wrote this on my phone, so I probably made some mistakes. I didn't bother to add remove() or error handling, but that should be straight-forward.
>>93 http://en.wikipedia.org/wiki/Whoopi_Goldberg She adopted the traditionally German/Jewish surname Goldberg as a stage name because her mother felt the original surname of Johnson was not "Jewish enough" to make her a star.
She had a smart mother.
Name:
Anonymous2012-01-15 1:18
>>97
Goldberg made a sexual joke about President George W. Bush, by waving a bottle of wine, pointing toward her pubic area and saying: "We should keep Bush where he belongs, and not in the White House."