Отображение из шестнадцатеричного числа в char с помощью условного оператора

Question

Поэтому я хочу, чтобы моя программа отображала следующее:
(адрес памяти) (16 байтов шестнадцатеричных значений) (эти шестнадцатеричные значения в символах)
Теперь у меня есть формат правильно, кроме следующей строки всегда возвращает '0' и поэтому никакие символы не отображаются вообще:
printf("%c", isgraph(*startPtr)? *startPtr:'.');
Наконец, я думаю, что я использую srand а также rand правильно, но мой массив не заполняется случайными вещами. Это всегда то же самое.
Во всяком случае, вот код:

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

void DumpMem(void *arrayPtr, int numBytes);
void FillMem(void *base, int numBytes);

int main(void)
{
    auto int numBytes;
    auto double *doublePtr;
    auto char *charPtr;
    auto int *intPtr;

    srand(time(NULL));
    // Doubles
    printf("How many doubles? ");
    scanf("%d", &numBytes);
    doublePtr = malloc(numBytes * sizeof(*doublePtr));

    if (NULL == doublePtr)
    {
        printf("Malloc failed!");
    }

    printf("Here's a dynamic array of doubles... \n");
    FillMem(doublePtr, numBytes * sizeof(*doublePtr));
    DumpMem(doublePtr, numBytes * sizeof(*doublePtr));
    // Chars
    printf("\nHow many chars? \n");
    scanf("%d", &numBytes);
    charPtr = malloc(numBytes * sizeof(*charPtr));

    if (NULL == charPtr)
    {
        printf("Malloc failed!");
    }

    printf("Here's a dynamic array of chars... \n");
    FillMem(charPtr, numBytes * sizeof(*charPtr));
    DumpMem(charPtr, numBytes * sizeof(*charPtr));
    // Ints
    printf("\nHow many ints? \n");
    scanf("%d", &numBytes);
    intPtr = malloc(numBytes * sizeof(*intPtr));

    if (NULL == intPtr)
    {
        printf("Malloc failed!");
    }

    printf("Here's a dynamic array of ints... \n");
    FillMem(intPtr, numBytes * sizeof(*intPtr));
    DumpMem(intPtr, numBytes * sizeof(*intPtr));

    // Free memory used
    free(doublePtr);
    free(charPtr);
    free(intPtr);
}

void DumpMem(void *arrayPtr, int numBytes)
{
    auto unsigned char *startPtr = arrayPtr;
    auto int counter = 0;
    auto int asciiBytes = numBytes;

    while (numBytes > 0)
    {
        printf("%p ", startPtr);

        for (counter = 0; counter < 8; counter++)
        {
            if (numBytes > 0)
            {
                printf("%02x ", *startPtr);
                startPtr++;
                numBytes--;
            }
            else
            {
                printf("   ");
            }
        }

        printf(" ");

        for (counter = 0; counter < 8; counter++)
        {
            if (numBytes > 0)
            {
                printf("%02x ", *startPtr);
                startPtr++;
                numBytes--;
            }
            else
            {
                printf("   ");
            }
        }

        printf(" |");
        // 'Rewind' where it's pointing to
        startPtr -= 16;

        for (counter = 0; counter < 16; counter++)
        {
            if (asciiBytes > 0)
            {
                printf("%c", isgraph(*startPtr)? *startPtr:'.');
                asciiBytes--;
            }
            else
            {
                printf(" ");
            }
        }
        puts("| ");
    }
}

void FillMem(void *base, int numBytes)
{
    auto unsigned char *startingPtr = base;

    while (numBytes > 0)
    {
        *startingPtr = (unsigned char)rand;
        numBytes--;
        startingPtr++;
    }
}

Почему я не получаю случайные значения внутри массива? И почему мое условное утверждение всегда 'false'?

Answer 1

Вы заполняете свой массив младшим байтом указателя на функцию rand, а не со случайным числом. Вам нужно вызвать функцию:

    *startingPtr = (unsigned char)rand();

Вы также не увеличиваете startPtr во время печати символьных данных. Тебе необходимо startPtr++ там:

        if (asciiBytes > 0)
        {
            printf("%c", isgraph(*startPtr)? *startPtr:'.');
            startPtr++;
            asciiBytes--;
        }

В таком виде ваша программа просто печатает первый байт снова и снова, а затем переходит на следующую строку и печатает идентичный предыдущей строке.