C / C++ / MFC

#include <Security.h>

#include <stdio.h>

#define SIZE 20
int main()
{
  int items, odd_items, even_items;
  int array[SIZE], odd[SIZE], even[SIZE];
  printf("enter how many array elements\n");

  scanf("%d",&items);


  odd_items = even_items = 0;

  for (int n=0; n<items; ++n)
  {
    printf("enter item %d:\n", n);
    scanf("%d", &array[n]);

    if ( (array[n] % 2) == 0)
    {
      even[even_items] = array[n];
      ++even_items;
    }
    else
    {
      odd[odd_items] = array[n];
      ++odd_items;
    }
  }

  printf("array items\n");
  for (int n=0; n<items; ++n)
    printf("%d ", array[n]);
  printf("\n");

  printf("even array items\n");
  for (int n=0; n<even_items; ++n)
    printf("%d ", even[n]);
  printf("\n");

  printf("odd array items\n");
  for (int n=0; n<odd_items; ++n)
    printf("%d ", odd[n]);
  printf("\n");

  return 0;
}

char *const p=str;
  |  |  |   |
  |  |  |   +- the variable p
  |  |  +----- is a constant
  |  +---------pointer
  +------------to a character

const char* p=str; // p is a pointer to a character constant.

void my_callback(void)...  /* This is the callback function that will be invoked. */

int main(void)
{
   callback ptr_my_callback = my_callback;  /* ptr_my_callback points to the function my_callback */
   register_callback(ptr_my_callback);      /* registers the callback */
}

/* This defines the type "callback". The '*' before "callback", which is in
parentheses, means that it's a pointer to a function. The function returns
void and takes (void) as its parameter. */

typedef void (*callback)(void);

/* This function is called to register the callback. It actually doesn't do
that, because registering would mean saving a pointer to it. All that it does
is invoke the function immediately, which is what it could do later if it
saved its parameter somewhere and used it to call the function when it was
time to do so. To call the function, it dereferences the pointer to it and
invokes it with no arguments. */

void register_callback(callback ptr_reg_callback)
{
   (*ptr_reg_callback)();
}