木構造を使い変数のアドレスを保持する。当然変数のスコープが抜けたらアドレスは不定となる。グローバル変数のアドレスを保持するぶんには使える

DataStore2.c

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

#define ARRAY_NUM(x) ((sizeof(x)) / (sizeof(x[0])))

typedef struct _tag_tree_node
{
	char* key;
	void* val;
	int size;
	struct _tag_tree_node *left;
	struct _tag_tree_node *right;
} tree_node;

tree_node* tree_root = NULL;

tree_node* create_new_node(char* key, void* val, int size)
{
	tree_node* tree_new;

	tree_new = (tree_node*)malloc(sizeof(tree_node));
	if (tree_new == NULL)
	{
		exit(EXIT_FAILURE);
	}
	tree_new->left = NULL;
	tree_new->right = NULL;
	tree_new->key = (char*)malloc(sizeof(char) * strlen(key) + 1);
	if (tree_new->key == NULL)
	{
		exit(EXIT_FAILURE);
	}
	strcpy(tree_new->key, key);
	tree_new->val = val;
	tree_new->size = size;

	return tree_new;
}

void insert_tree(char* key, void* val, int size, tree_node *node)
{
	if (node == NULL)
	{
		tree_root = create_new_node(key, val, size);
		return;
	}

	if (strcmp(node->key, key) > 0)
	{
		if (node->left != NULL)
		{
			insert_tree(key, val, size, node->left);
		}
		else
		{
			node->left = create_new_node(key, val, size);
		}
	}
	else
	{
		if (node->right != NULL)
		{
			insert_tree(key, val, size, node->right);
		}
		else
		{
			node->right = create_new_node(key, val, size);
		}
	}
	return;
}

tree_node* find_key(tree_node* node, char* key)
{

	int cmp = strcmp(node->key, key);
	if (cmp > 0)
	{
		if (node->left == NULL)
		{
			return NULL;
		}
		return find_key(node->left, key);
	}
	if (cmp < 0)
	{
		if (node->right == NULL)
		{
			return NULL;
		}
		return find_key(node->right, key);
	}

	return node;
}

void free_tree(tree_node* node)
{
	if (node == NULL)
	{
		return;
	}
	free_tree(node->left);
	free_tree(node->right);

	free(node->key);
	free(node);
}

int main(int ac, char** av)
{
	int i;
	tree_node *node_found;
	int a = 4;
	int b[] = { 0, 1, 2 };
	int c[][3] = {
		{ 0, 1, 2 },
		{ 3, 4, 5 },
		{ 6, 7, 8 },
	};

	struct hogeT
	{
		int a;
		int b;
	} hoge;

	hoge.a = 1;
	hoge.b = 2;


	insert_tree("aaa", &a, sizeof(int), tree_root);
	insert_tree("bbb", &b, ARRAY_NUM(b) * sizeof(int), tree_root);
	insert_tree("ccc", &c, ARRAY_NUM(b) * 3 * sizeof(int), tree_root);
	insert_tree("d", &hoge, sizeof(struct hogeT), tree_root);

	node_found = find_key(tree_root, "aaa");
	if (node_found != NULL)
	{
		int v = *(int*)node_found->val;
		printf("%s => %d\n", node_found->key, v);
	}

	node_found = find_key(tree_root, "bbb");
	if (node_found != NULL)
	{
		int* v = (int*)node_found->val;
		printf("%s => %d %d %d\n", node_found->key, v[0], v[1], v[2]);
	}

	node_found = find_key(tree_root, "ccc");
	if (node_found != NULL)
	{
		int i;
		int (*v)[3] = (int(*)[3])(node_found->val);
		for (i = 0; i < 3; i++)
		{
			printf("[%d] %d %d %d\n", i, v[i][0], v[i][1], v[i][2]);
		}
	}

	node_found = find_key(tree_root, "d");
	if (node_found != NULL)
	{
		struct hogeT v = *(struct hogeT*)node_found->val;
		printf("%s => %d %d\n", node_found->key, v.a, v.b);
	}


	free_tree(tree_root);
	return EXIT_SUCCESS;
}