The Big Programming Thread - Page 576

# define TAB_TYPE char

TAB_TYPE	**tab_realloc(TAB_TYPE **old_tab, int old_size, int new_size)
{
	TAB_TYPE	**res;
	int			i;

	if (!(res = (TAB_TYPE **)ft_memalloc(sizeof(TAB_TYPE *) * new_size)))
		return (NULL);
	i = 0;
	while (i < new_size)
	{
		if (i < old_size)
		{
                        res[i] = old_tab[i];
			ft_memdel((void **)&old_tab[i]);
		}
		else
			res[i] = NULL;
		i++;
	}
	ft_memdel((void **)old_tab);
	return (res);
}

res = malloc(sizeof(void*) * new_size);
memset(res, 0, sizeof(void*) * new_size);
if (new_size < old_size)
  memcpy(res, old_tab, sizeof(void*) * new_size);
else
  memcpy(res, old_tab, sizeof(void*) * old_size);
free(old_tab);
return res;

res = malloc(sizeof(void*) * new_size);
memset(res, 0, sizeof(void*) * new_size);
if (new_size < old_size)
  memcpy(res, old_tab, sizeof(void*) * new_size);
else
  memcpy(res, old_tab, sizeof(void*) * old_size);
free(old_tab);
return res;

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

struct DiceConfiguration
{
    int DiceNumber;
    int DiceType;
};

struct DiceThrowsResult
{
    int DiceNumber;
    int Sum;
    int ThrowsResults[];
};

struct DiceConfiguration* GetConfiguration();
struct DiceThrowsResult* ThrowDices(struct DiceConfiguration *config);
void GenerateRandomSeed(void);
int ThrowDice(struct DiceConfiguration *config);
void PrintDiceThrowsResult(struct DiceThrowsResult *result);
void ReleaseMemory(struct DiceConfiguration *config, struct DiceThrowsResult *result);

int main(void)
{
    struct DiceConfiguration *config;
    struct DiceThrowsResult *result;

    GenerateRandomSeed();

    config = GetConfiguration();

    while(config != NULL)
    {
        result = ThrowDices(config);

        PrintDiceThrowsResult(result);

        ReleaseMemory(config, result);

        config = GetConfiguration();
    }

    return 0;
}

struct DiceConfiguration* GetConfiguration()
{
    int diceNumber = 0;
    int diceType = 0;

    printf("Enter the number of dice to throw (0 to quit): ");
    scanf("%d", &diceNumber);

    if(diceNumber == 0)
    {
        return NULL;
    }
    else
    {
        printf("Enter dice type (sides): ");
        scanf("%d", &diceType);

        if(diceType < 2)
        {
            printf("Dice can't have less than 2 sides!\n");

            return NULL;
        }
        else
        {
            struct DiceConfiguration *config;
            config = malloc(sizeof(struct DiceConfiguration));

            config->DiceNumber = diceNumber;
            config->DiceType = diceType;

            return config;
        }
    }
}

struct DiceThrowsResult* ThrowDices(struct DiceConfiguration *config)
{
    struct DiceThrowsResult *result;
    result = malloc(sizeof(struct DiceThrowsResult) + config->DiceNumber * sizeof(int));
    result->DiceNumber = config->DiceNumber;

    for (int i = 0; i < config->DiceNumber; i += 1)
    {
        result->ThrowsResults[i] = ThrowDice(config);
        result->Sum += result->ThrowsResults[i];
    }

    return result;
}

void GenerateRandomSeed(void)
{
    srand((unsigned int) time(0));
}

int ThrowDice(struct DiceConfiguration *config)
{
    return rand() % config->DiceType + 1;
}

void PrintDiceThrowsResult(struct DiceThrowsResult *result)
{

    for (int i = 0; i < result->DiceNumber; i += 1)
    {
        printf("%d ", result->ThrowsResults[i]);
    }

    printf("Sum: %d\n", result->Sum);
}

void ReleaseMemory(struct DiceConfiguration *config, struct DiceThrowsResult *result)
{
    if (config != NULL)
    {
        free(config);
        config = NULL;
    }

    if (result != NULL)
    {
        free(result);
        result = NULL;
    }
}

switch (string.c_str())