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)();
}

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));

struct foo {
 char key[10];
 int id;
 /* more members */
};

/* comparison function to sort struct foo by key */
int cmpfoo_bykey(const void *vp1, const void *vp2)
{
  const struct foo *foo1 = vp1;
  const struct foo *foo2 = vp2;

  return strcmp(foo1->key, foo2->key);
}

/* comparison function to sort struct foo by id */
int cmpfoo_byid(const void *vp1, const void *vp2)
{
  const struct foo *foo1 = vp1;
  const struct foo *foo2 = vp2;

  return foo1->id - foo2->id;
}

int main()
{
   struct foo my_data[100];
   /* load data into my_data : not show here*/

   /* sort my_data by key field */
   qsort(my_data, 100, sizeof(struct foo), cmpfoo_bykey);

   /* use my_data in key-ordered way ... */

   /* sort my_data by id field */
   qsort(my_data, 100, sizeof(struct foo), cmpfoo_byid);

  /* use my_data in id-ordered way ... */

  return 0;
}