C / C++ / MFC

#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;
}

Quote:

Does anybody know how I can achieve this in the easiest way possible?

Quote:

Is the source code for printf available somewhere for public use so I can modify it to fit my needs?

Mircea Neacsu wrote:

Not sure if easiest but one common way of doing it is to have printf call a putc-type function to send out each succesive character. In your case, the "putc" function would be the UART output function.

Mircea Neacsu wrote:

Plenty of those. One I've used before in an embedded environment is for Rabbit microcontrollers. You can find the relevant code here: DCRabbit_10/STDIO.LIB at master · digidotcom/DCRabbit_10 · GitHub[^]

Quote:

I am working with STM32F-microcontrollers, would you happen to know if it's easy to replace the putc-function for their printf-function?

CPallini wrote:

in order to use just a small buffer you need to append characters to the buffer while there is still available space and wait patiently the transmission of characters in order to use the buffer again. This means you can't actually use a function call similar to the printf one.