Displaying hex values inside an array to stdout, and comparing input to those hex values

Question

This is my current code:

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

int main()
{
    int target;
    char array[] = {'AC', 'EE', '88', '0D', '87'};

    printf("Enter the target byte as a hex value: \n");
    scanf("%x", &target);

    int i = 0;
    for (i; i < 5; i++)
    {
        printf("Value of array[%d] is %x \n", i, array[i]);
    }

    int i = 0;
    for (i; i < 5; i++)
    {
        if (memcmp(target, array, sizeof(target) == 0))
        {
            printf("Found a match!");
        }
    }
}

(1) I want to be able to display to stdout the exact values inside of my char array[]. Things I've tried that do not work: displaying the array as %c, %x, %d.
(2) After I get the input from the user, I want to be able to compare that input to the characters inside of the array - figured memcmp would be the way to go, but how do I traverse through the entire array? I tried doing if (memcmp(target, array[i], sizeof(target) == 0)) but I'd get a runtime error because of the array[i] part, but if I don't add that part, how will it go through the entire array comparing the values stored in each array memory location to the value stored in the target variable? I basically want to compare bytes inside each array location to the bytes the input by the user.

Answer 1

1. You should store the hex values in your array as 0xAC etc, not 'AC' (which is a multi character constant and not at all what you want).
2. Store your hex values as unsigned char because on platforms where char defaults to signed you're going to get some values (negative ones) being cast to int and sign-bit padded accordingly, which is then displayed.
3. Your memcmp is call wrong and using it is unnecessary anyway.
4. Your example code won't compile because you have two declarations of int i in the same scope. If you aren't using C89 why aren't you writing your for loops as for(int i = 0;...) anyway?
5. Don't forget your return value for main.

Example:

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

int main(void)
{
  int target;
  const unsigned char array[] = { 0xAC, 0xEE, 0x88, 0x0D, 0x87 };
  const int len = sizeof array;

  printf("Enter the target byte as a hex value: \n");
  scanf("%x", &target);

  for (int i = 0; i < 5; ++i)
  {
    printf("Value of array[%d] is 0x%x\n", i, array[i]);
  }

  for (int i = 0; i < len; ++i)
  {
    if (target == array[i])
    {
      printf("Found a match!\n");
    }
  }

  return EXIT_SUCCESS;
}

Answer 2

This question was part of a bigger program, but it was just this small portion that I couldn't figure out to begin with. In the end, I got everything worked out. Below is the final code of the actual program, and at the bottom are the function definitions I wrote with the help of a couple of users. Again, thank you!

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


// defined constants
#define MAX_WIDTH       20
#define NUMELEMS        50


// typedefs and function prototypes
typedef unsigned char   Byte;
void DispBytes(void *voidArray, int totalBytes);
int CountMatchBytes(void *voidArray, int totalBytes, int targetHex);


// ==== main ==================================================================
//
// ============================================================================

int     main(void)
{
    auto    double          myDoubles[NUMELEMS];
    auto    int             myInts[NUMELEMS];
    auto    char            myChars[NUMELEMS];
    auto    int             target;
    auto    int             numMatches;

    // process the char array
    puts("Here's the array of chars as bytes: ");
    DispBytes(myChars, sizeof(myChars));
    printf("\nEnter the target byte as a hex value: ");
    scanf("%x", &target);
    numMatches = CountMatchBytes(myChars, sizeof(myChars), target);
    printf("There %s %d matching byte%s.\n\n", (1 == numMatches ? "is" : "are")
                                             , numMatches
                                             , (1 == numMatches ? "" : "s"));
    // process the int array
    puts("\nHere's the array of ints as bytes: ");
    DispBytes(myInts, sizeof(myInts));
    printf("Enter the target byte as a hex value: ");
    scanf("%x", &target);
    numMatches = CountMatchBytes(myInts, sizeof(myInts), target);
    printf("There %s %d matching byte%s.\n\n", (1 == numMatches ? "is" : "are")
                                             , numMatches
                                             , (1 == numMatches ? "" : "s"));
    // process the double array
    puts("\nHere's the array of doubles as bytes: ");
    DispBytes(myDoubles, sizeof(myDoubles));
    printf("Enter the target byte as a hex value: ");
    scanf("%x", &target);
    numMatches = CountMatchBytes(myDoubles, sizeof(myDoubles), target);
    printf("There %s %d matching byte%s.\n\n", (1 == numMatches ? "is" : "are")
                                             , numMatches
                                             , (1 == numMatches ? "" : "s"));

    return  0;

}  // end of "main"

void DispBytes(void *voidArray, int totalBytes)
{
    // Sets startingPtr to the base address of the passed array
    auto unsigned char *startingPtr = voidArray;
    // Sets endingPtr to one address past the array
    auto unsigned char *endPtr = voidArray + totalBytes;
    auto int counter = 0;

    // Loop while the address of startingPtr is less than endPtr
    while (startingPtr < endPtr)
    {
        // Display the values inside the array
        printf("%x ", *startingPtr);
        counter++;

        if (counter == MAX_WIDTH)
        {
            printf("\n");
            counter = 0;
        }
        // Increment the address of startingPtr so it cycles through
        // every value inside the array
        startingPtr++;
    }
}

int CountMatchBytes(void *voidArray, int totalBytes, int targetHex)
{
    // Sets startingPtr to the base address of the passed array
    auto unsigned char *startingPtr = voidArray;
    // Sets endingPtr to one address past the array
    auto unsigned char *endingPtr = voidArray + totalBytes;
    auto int counter = 0;
    // Loop while the address of startingPtr is less than endPtr
    while (startingPtr < endingPtr)
    {
        // If the input value is the same as the value inside
        // of that particular address inside the array,
        // increment counter
        if (targetHex == *startingPtr)
        {
            counter++;
        }
        // Increment the address of startingPtr so it cycles through
        // every value inside the array
        startingPtr++;
    }
    // Return the number of times the input value was found
    // within the array
    return counter;
}