/fefe/ – Fefes Kommentarfunktion

#include <stdio.h>

struct Base
{
	int member1;
};

struct Derived1 : public Base
{
	int member2;
	int member3;
};

int diff1(Base * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += arr[i+1].member1 - arr[i].member1;

	return result;
}

int diff2(Derived1 * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += arr[i+1].member1 - arr[i].member1;

	return result;
}

int main(int /*argc*/, char ** /*argv*/)
{
	Derived1 arr[8];

	for(size_t i = 0; i < 8; i++)
	{
		arr[i].member1 = 1;
		arr[i].member2 = 5;
		arr[i].member3 = 1337;
	}

	printf("%d\n", diff1(arr, 8));
	printf("%d\n", diff2(arr, 8));

	return 0;
}

typedef struct {
  int weight;
  int age;
} pet;

typedef struct {
  pet p;
  char *name;
} dog;

int get_age(pet *p) {
  return p->age;
}

dog *new_dog(int weight, int age, char *name) {
  dog *rex = malloc(sizeof(dog));
  ((pet *)rex)->weight = weight;
  ((pet *)rex)->age = age;
  rex->name = name;
  return rex;
}

dog *rex = new_dog(40, 5, "Rex");
int age = get_age(rex)

with Ada.Text_IO; use Ada.Text_IO; with Ada.Unchecked_Conversion; use Ada;

procedure Main is
    type Base is tagged record
        member1 : Integer;
    end record;
    
    type Derived1 is new Base with record
        member2 : Integer;
        member3 : Integer;
    end record;

    type BaseArray is array (1 .. 8) of Base;
    type Derived1Array is array (1 .. 8) of Derived1;
    function ToBaseArray is new Unchecked_Conversion(Derived1Array, BaseArray);

    function diff1(arr : in BaseArray) return Integer is
        result : Integer := 0;
    begin
        for i in 1 .. arr'Last - 1 loop
            result := result + arr(i+1).member1 - arr(i).member1;
        end loop;
        
        return result;
    end diff1;

    function diff2(arr : in Derived1Array) return Integer is
        result : Integer := 0;
    begin
        for i in 1 .. arr'Last - 1 loop
            result := result + arr(i+1).member1 - arr(i).member1;
        end loop;
        
        return result;
    end diff2;

    arr : Derived1Array;
begin
    for i in arr'Range loop
        arr(i).member1 := 1;
        arr(i).member2 := 5;
        arr(i).member3 := 1337;
    end loop;

    Put_Line(Integer'Image(diff1(ToBaseArray(arr))));
    Put_Line(Integer'Image(diff2(arr)));
end Main;

#include <stdio.h>

typedef struct
{
	int member1;
} Base;

// Kompiler-generiert
#define BASE_MEMBERS \
	int member1;

// Derived1 erbt von Base
typedef struct
{
	BASE_MEMBERS // Kompiler-generiert
	int member2;
	int member3;
} Derived1;

// Kompiler-generiert, ein einziges Mal für die gesamte Hierarchie (da _zur Kompilierzeit_ bekannt)
typedef union
{
	Base Base;
	Derived1 Derived1;
} Polymorph_Base_Derived1;

// Kompiler-generiert
#define CONCAT_IMPL(a, b) a ## b
#define CONCAT(a, b) CONCAT_IMPL(a, b)
#define Polymorph_Base Polymorph_Base_Derived1
#define Polymorph_Derived1 Polymorph_Base_Derived1
#define Polymorph_Member(c, x) x.c
#define Polymorph(x) CONCAT(Polymorph, CONCAT(_, x))

// Benutzt nur "Base"
int diff1(Polymorph(Base) * arr, size_t n) // "Polymorph(Base)" ist Kompiler-generiert
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		// "Polymorph_Member" ist Kompiler-generiert
		result += Polymorph_Member(Base, arr[i+1]).member1 - Polymorph_Member(Base, arr[i]).member1;

	return result;
}

// Benutzt nur "Derived1"
int diff2(Polymorph(Derived1) * arr, size_t n) // "Polymorph(Derived1)" ist Kompiler-generiert
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		// "Polymorph_Member" ist Kompiler-generiert
		result += Polymorph_Member(Derived1, arr[i+1]).member1 - Polymorph_Member(Derived1, arr[i]).member1;

	return result;
}

int main(int argc, char ** argv)
{
	// "Polymorph(x)" ist Kompiler-generiert für Arrays mit einem Typ, welcher Teil einer Vererbungs-Hierarchie ist
	// (es sei denn, der Benutzer spezifiziert, dass er das nicht möchte, z.B. für ein Array von Base).
	// arr ist ein Werte-Array und speichert kontinuierlich: member1, member2, member3, member1, ...
	Polymorph(Derived1) arr[8];

	for(size_t i = 0; i < 8; i++)
	{
		Polymorph_Member(Derived1, arr[i]).member1 = 1;		// "Polymorph_Member" ist Kompiler-generiert
		Polymorph_Member(Derived1, arr[i]).member2 = 5;		// "Polymorph_Member" ist Kompiler-generiert
		Polymorph_Member(Derived1, arr[i]).member3 = 1337;	// "Polymorph_Member" ist Kompiler-generiert
	}

	printf("%d\n", diff1(arr, 8));
	printf("%d\n", diff2(arr, 8));

	return 0;
}

#include <stdio.h>

struct Base
{
	int member1;
};

struct Derived1
{
	struct Base parent;
	int member2;
	int member3;
};

int diff(struct Base *a, struct Base *b)
{
	return b->member1 - a->member1;
}

int main(int, char **)
{
	struct Derived1 arr[8];

	for(size_t i = 0; i < 8; i++)
	{
		((struct Base*)&arr[i])->member1 = 1;
		arr[i].member2 = 5;
		arr[i].member3 = 1337;
	}

	int sum = 0;
	int n = sizeof(arr) / sizeof(arr[0]);

	for(size_t i = 0; i < n - 1; i++)
		sum += diff((struct Base*)&arr[i], (struct Base*)&arr[i+1]);

	printf("%d\n", sum);

	return 0;
}

int diff(struct Base *arr, size_t n, size_t member_size)
{
	int result = 0;
	for (size_t i = 0; i + 1 < n; ++i) {
		struct Base *a = (void*)((char*)arr + member_size * i);
		struct Base *b = (void*)((char*)arr + member_size * (i + 1));
		result += b->member1 - a->member1;
	}
	return result;
}

int main(int, char **)
{
	struct Derived1 arr[8];

	for(size_t i = 0; i < 8; i++)
	{
		((struct Base*)&arr[i])->member1 = 1;
		arr[i].member2 = 5;
		arr[i].member3 = 1337;
	}

	int n = sizeof(arr) / sizeof(arr[0]);

	int sum = diff((struct Base*)&arr[0], n, sizeof(arr[0]));
	printf("%d\n", sum);

	return 0;
}

#include <stdio.h>

struct Base
{
	int member1;
};

struct Derived1
{
	struct Base parent;
	int member2;
	int member3;
};

enum { MAX_ARRAY_SIZE = 1024 };

struct MyAllocator {
	char buf[MAX_ARRAY_SIZE];
	size_t offset[MAX_ARRAY_SIZE];
	size_t n;
};

void *my_allocator_alloc(struct MyAllocator *allocator, size_t elem_size)
{
	// Alignment und bounds-checking ignorieren wir hier mal
	size_t n = allocator->n;
	size_t offset = allocator->offset[n];
	allocator->offset[n + 1] = offset + elem_size;
	++allocator->n;
	return (void*)(&allocator->buf[offset]);
}

void *my_allocator_get(struct MyAllocator *allocator, size_t index)
{
	size_t offset = allocator->offset[index];
	return (void*)(&allocator->buf[offset]);
}

int diff(struct MyAllocator *allocator)
{
	int result = 0;
	for (size_t i = 0; i + 1 < allocator->n; ++i) {
		struct Base *a = my_allocator_get(allocator, i);
		struct Base *b = my_allocator_get(allocator, i+1);
		result += b->member1 - a->member1;
	}
	return result;
}

int main(int, char **)
{
	struct MyAllocator allocator = {0};

	for(size_t i = 0; i < 8; i++)
	{
		struct Base *elem = my_allocator_alloc(&allocator, sizeof(*elem));
		elem->member1 = 1;
	}

	// Und weil es so schön ist, gleich noch mal, aber diesmal mit Derived1
	for(size_t i = 0; i < 8; i++)
	{
		struct Derived1 *elem = my_allocator_alloc(&allocator, sizeof(*elem));
		((struct Base*)elem)->member1 = 1;
		elem->member2 = 5;
		elem->member3 = 1337;
	}

	int sum = diff(&allocator);
	printf("%d\n", sum);

	return 0;
}

int diff_Base(Base * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += arr[i+1].member1 - arr[i].member1;

	return result;
}

int diff_Derived1(Derived1 * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += arr[i+1].member1 - arr[i].member1;

	return result;
}

int diff_Polymorph(Polymorph_Base_Derived1 * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += Polymorph_Member(Base, arr[i+1]).member1 - Polymorph_Member(Base, arr[i]).member1;

	return result;
}

int main(int argc, char ** argv)
{
	Polymorph_Base_Derived1 arr[8];

	for(size_t i = 0; i < 8; i++)
	{
		Polymorph_Member(Base, arr[i]).member1 = (int)(i);
		Polymorph_Member(Derived1, arr[i]).member2 = 5;
		Polymorph_Member(Derived1, arr[i]).member3 = 1337;
	}

	//printf("%d\n", diff_Base(arr, 8)); // Kompiler-Fehler
	//printf("%d\n", diff_Derived1(arr, 8)); // Kompiler-Fehler
	printf("%d\n", diff_Polymorph(arr, 8));

	return 0;
}

#define ArrayGet(dest, arr, i, stride, Type, MemberType, member) memcpy(&(dest), (char *)(arr) + (i) * (stride) + offsetof(Type, member), sizeof(MemberType))

int diff(void * arr, size_t n, size_t stride)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
	{
		int a, b;
		ArrayGet(a, arr, i, stride, Base, int, member1);
		ArrayGet(b, arr, i+1, stride, Base, int, member1);

		result += b - a;
	}

	return result;
}

int main(int argc, char ** argv)
{
	Base arr1[8];

	for(size_t i = 0; i < 8; i++)
	{
		arr1[i].member1 = (int)(i);
	}

	printf("%d\n", diff(arr1, 8, sizeof(Base)));

	Derived1 arr2[8];

	for(size_t i = 0; i < 8; i++)
	{
		arr2[i].member1 = (int)(i);
		arr2[i].member2 = 5;
		arr2[i].member3 = 1337;
	}

	printf("%d\n", diff(arr2, 8, sizeof(Derived1)));

	Polymorph_Base_Derived1 arr3[8];

	for(size_t i = 0; i < 8; i++)
	{
		// Es wird mit Derived1 befüllt
		Polymorph_Member(Derived1, arr3[i]).member1 = (int)(i);
		Polymorph_Member(Derived1, arr3[i]).member2 = 5;
		Polymorph_Member(Derived1, arr3[i]).member3 = 1337;
	}

	printf("%d\n", diff(arr3, 8, sizeof(Polymorph_Base_Derived1)));

	return 0;
}

template <typename T>
int diff(T * arr, size_t n)
{
	int result = 0;

	for(size_t i = 0; i < n - 1; i++)
		result += arr[i+1].member1 - arr[i].member1;

	return result;
}

template <typename T>
int diff(T * a, T * b)
{
	return b->parent.member1 - a->parent.member1;
}

template <typename T>
int ProcessArray(T * arr, size_t n)
{
	int sum = 0;

	for(size_t i = 0; i < n - 1; i++)
		sum += diff(&arr[i], &arr[i+1]);

	return sum;
}

int main(int argc, char ** argv)
{
	size_t n = 8;
	Derived1 * arr = CreateDerived1Array(n);
	InitializeDerived1Array(arr, n);

	int sum = ProcessArray(arr, n);
	printf("%d\n", sum);

	DestroyDerived1Array(arr);

	return 0;
}

class MyClass
{
	std::vector<std::unique_ptr<Base>> v;

public:
	void DoSomething()
	{
		for(auto & i : v)
			i->DoSomething();
	}
};

class MyClass
{
	Base * b;

public:
	void DoSomething()
	{
		b->DoSomething();
	}
};

void f(std::vector<MyClass> & v)
{
	for(auto & i : v)
		i.DoSomething();
}

#include <stdio.h>
#include <algorithm>

struct Base
{
	int member1;
};

struct Derived1 : public Base
{
	int member2;
	int member3;
};

void Sort1(Base * arr, size_t n)
{
	std::sort(arr, arr + n, [](Base & a, Base & b)
	{
		return a.member1 < b.member1;
	});
}

void Sort2(Base * begin, Base * end)
{
	std::sort(begin, end, [](Base & a, Base & b)
	{
		return a.member1 < b.member1;
	});
}

int main(int /*argc*/, char ** /*argv*/)
{
	Derived1 arr[8];

	for(int i = 0; i < 8; i++)
	{
		arr[i].member1 = i * 2;
		arr[i].member2 = 5;
		arr[i].member3 = 1337;
	}

	Sort1(arr, sizeof(arr) / sizeof(arr[0]));

	printf("%d\n", arr[0].member1);   // 0
	printf("%d\n", arr[1].member1);   // 5
	printf("%d\n", arr[2].member1);   // 1337
	printf("%d\n", arr[3].member1);   // 6

	//Sort2(arr, arr + sizeof(arr) / sizeof(arr[0]));

	//printf("%d\n", arr[0].member1);   // 0
	//printf("%d\n", arr[1].member1);   // 5
	//printf("%d\n", arr[2].member1);   // 5
	//printf("%d\n", arr[3].member1);   // 5

	return 0;
}

struct Parent {
  int field1;
};

struct Child {
  struct Parent parent;
  int field2;
}

int main()
{
  struct Child child;
  //struct Parent *parent = (struct Parent*)&child;
  struct Parent *parent = &child.parent; 
}

pkg-config --cflags glib-2.0
-I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include -I/usr/include/sysprof-6 -pthread

/* We need GCC for __extension__, which we need to sort out strict aliasing of @object_ptr */
#if defined(__GNUC__)

#define g_set_object(object_ptr, new_object) \
  (G_GNUC_EXTENSION ({ \
    G_STATIC_ASSERT (sizeof *(object_ptr) == sizeof (new_object)); \
    /* Only one access, please; work around type aliasing */ \
    union { char *in; GObject **out; } _object_ptr; \
    _object_ptr.in = (char *) (object_ptr); \
    /* Check types match */ \
    (void) (0 ? *(object_ptr) = (new_object), FALSE : FALSE); \
    (g_set_object) (_object_ptr.out, (GObject *) new_object); \
  })) \
  GOBJECT_AVAILABLE_MACRO_IN_2_44