tree myTree; // auto-allocated tree object
tree *pTree; // unassigned pointer to a tree object
pTree = &myTree; // take the address of myTree with the unary operator & and assign it to the pointer

nielsm fucked around with this message at 21:15 on Apr 14, 2011

Princess Kakorin fucked around with this message at 21:20 on Apr 14, 2011

Paniolo fucked around with this message at 03:16 on Apr 15, 2011

TasteMyHouse fucked around with this message at 02:21 on Apr 15, 2011

int* a;

Fecotourist fucked around with this message at 04:21 on Apr 16, 2011

raminasi fucked around with this message at 23:12 on Apr 17, 2011

• (g)make - Very simple, as long as you use -rR. Doesn't know about header files. There's a tradeoff between speed and correctness. makedepend and similar ideas scan the whole project, which is slow, because preprocessing is slow and with them, you're doing it twice. This is mitigated since it only runs with a `make depend`, which means that if you add a header file to a .c file and forget to run `make depend`, something might break someday. The method outlined in "Recursive Make Considered Harmful" is the most correct, but suffers from the same doubled preprocessing problem as makedepend, every time you compile something.
  
• mk - Simpler than make and I love it, but has the same issues with headers.
  
• cmake - Complex if you ever want to use tools that cmake doesn't have targets for. The language spec seems to change frequently. Little-to-no help with cross-platforming flags (e.g. '-' vs. '/', cl flag names vs. gcc names, etc.).
  
• scons - Complex if you ever want to use tools that scons doesn't expect on a platform (or more specifically, I couldn't get it to find flex and bison on Windows, no matter where I put the executables). Scales terribly. Little-to-no help with cross-platform flags.
  
• fabricate - Almost perfect, too bad strace is Linux-only and Windows and OS X don't updates atimes these days. It works fine if you use something like their GccRunner example, but that reintroduces the preprocessing slowdown.
  

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <dispatch/dispatch.h>

void merge (int *a, int *b, int n) {
    int i, *x, *p, *q;
    x = malloc(n * sizeof (int));
    for (i = 0, p = a, q = b; i < n; i++) 
        x[i] = p == b     ? *q++
             : q == a + n ? *p++
             : *p < *q    ? *p++
             :              *q++;
    memcpy(a, x, n * sizeof (int));
    free(x);
}   
 
void merge_sort (int *array, int size) {
  dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    __block int *barray;
    __block int  mize;
    __block int* x = array;
    __block size_t s = size;
    if (size < 2)
        return;
    mize = size / 2;
    barray = array + mize;
    dispatch_sync(queue, ^{ merge_sort(x, mize); });
    dispatch_sync(queue, ^{ merge_sort(barray, s - mize); });
    dispatch_sync(queue, ^{ merge(x, barray, s); });
}
 
int main () {
    int a[] = { 38454, 39623, 29947, 82648, 77273, 1000, 69098, 97177, 43038, 
48953, 45947, 89301, 89736, 14941, 12279, 770, 6131, 59887, 31072, 3094, 87250,
5825, 60157, 10205, 13800, 91165, 19772, 5988, 38175, 12220, 98188, 16303, 86756, 
51959, 82797, 69907, 49190, 90491, 67198, 75181, 47536, 70602, 63988, 8498, 82438, 
34486, 72590, 3989, 8389, 44731, 72012, 89406, 74028, 20521, 1818, 17349, 41147, 
29965, 53048, 78803, 4, 65, 2, -31, 0, 99, 2, 83, 782, 1};
    int n = sizeof a / sizeof a[0];
    merge_sort(a, n);
  for (int idx = 0; idx < n; ++idx) {
    printf("%i ", a[idx]);
  }
  puts("");
    return 0;
}

-31 0 1 2 2 4 65 83 99 770 782 1000 1818 3094 3989 5825 5988 6131 8389 8498 10205 
12220 12279 13800 14941 16303 17349 19772 20521 29947 29965 31072 34486 38175 
38454 39623 41147 43038 44731 45947 47536 48953 49190 51959 53048 59887 60157 
63988 67198 69098 69907 70602 72012 72590 74028 75181 77273 78803 82438 82648 
82797 86756 87250 89301 89406 89736 90491 91165 97177 98188 

Slurps Mad Rips fucked around with this message at 08:17 on Apr 18, 2011