int8_t a = 12;

printf("a:n arvo on %d ja sen muistiosoite on %p",a,&a); // %p on tulostusmääre osoitinmuuttujalle

int8_t *osoitin_a = &a; 
int8_t *osoitin_b = NULL; 

int8_t *osoitin_a = &a;

*osoitin_a = 44;  

int8_t *osoitin_a = &a;
int16_t *osoitin_x = &x;

printf("a=%d ja x=%4x", *osoitin_a, *osoitin_x);
// Joka  tulostaa
a=47 ja x=1234

int8_t a = 47;
int8_t *osoitin_a = &a; // sijoitetaan a:n osoite

printf("a:n muistiosoite on %p\n", &a); 
printf("osoitin_a:n oma muistiosoite on %p\n", &osoitin_a);
printf("osoitin_a:n osoittama muistiosoite %p\n", osoitin_a); 
printf("osoitin_a:n osoittamasta muistiosoitteesta haettu arvo %d\n", *osoitin_a); 

// Tulostaa
a:n muistiosoite on 0x7ffdbf42ad8f
osoitin_a:n oma muistiosoite on 0x7ffdbf42ad80
osoitin_a:n osoittama muistiosoite 0x7ffdbf42ad8f // Eli a:n osoite
osoitin_a:n osoittamasta muistiosoitteesta haettu arvo 47

int8_t a = 47;
int8_t *osoitin_a = &a; 
// Nyt *osoitin_a = 47

// 16-bittisen (kaksi tavua) muuttujan x esittely
int16_t x = 0x1234;

// Nyt, jos osoitin_x olisi tyyppiä int8_t eli yksi tavu
int8_t *osoitin_x = &x;
printf("x=%x", *osoitin_x);

// Tulostaa
x=12 

// ..kääntäjä noutaa x:n muistiosoitteesta vain ensimmäisen tavun
// ja toinen tavu (0x34) jää hakematta! 

// Jos osoitin_x olisi tyyppiä int32_t, se noutaisi x:n muistiosoitteesta neljä tavua
int32_t *osoitin_x = &x;
printf("x=%x", *osoitin_x);

// Tulostaa
x=12344142 

// haettiin x:n kaksi tavua ja lisäksi "liikaa" msg-muuttujan 
// kaksi ensimmäistä tavua..

// Siis kaikissa näissä osoitinmuuttujien koko on 16 bittiä
// vaikka se osoittaa eri kokoisiin muuttujiin
uint8_t  *ptr8 = &a;
uint16_t *ptr16 = &b;
uint32_t *ptr32 = %c;

char *osoitin_eka_msg = &msg[0]; // Osoittaa taulukon ensimmäiseen alkioon: arvo A
char *osoitin_toka_msg = &msg[1]; // Osoittaa taulukon toiseen alkioon: arvo B

osoitin_eka_msg:n arvo on 0x0033;
osoitin_toka_msg:n arvo on 0x0034; // +1  tavu, koska 8-bittinen luku 

int16_t *osoitin_eka_num = &num[0]; // Osoittaa taulukon ensimmäiseen alkioon: arvo 1
int16_t *osoitin_toka_num = &num[1]; // Osoittaa taulukon toiseen alkioon: arvo 2

osoitin_eka_num:n arvoksi tulee 0x0037;
osoitin_toka_num:n arvoksi tulee 0x0039; // +2 tavua, koska 16-bittinen luku

char *osoitin_msg = msg;
int16_t *osoitin_num = num;

char sukunimi[20];
char *osoitin = sukunimi;

printf("%p\n", &sukunimi[0]);
printf("%p\n", sukunimi); // !!!
printf("%p\n", &sukunimi); // !!! 
printf("%p\n", osoitin);

Joka tulostaa (luennoitsijan kotikoneessa)...
000000000023FE20
000000000023FE20
000000000023FE20
000000000023FE20

char *osoitin_msg = msg;
int16_t *osoitin_num = num;

// Koska osoitin on tyyppiä int8_t, sen arvo kasvaa yhden tavun verran
osoitin_msg = &msg[0];  // arvo 0x0033
osoitin_msg+1 = &msg[1]; // arvo 0x0034
osoitin_msg+2 = &msg[2]; // arvo 0x0035

// Koska osoitin on tyyppiä int16_t, sen arvo kasvaa kahden tavun verran
// vaikka indeksi kasvaakin vain yhdellä
osoitin_num = &num[0];  // arvo 0x0037
osoitin_num+1 = &num[1]; // arvo 0x0039
osoitin_num+2 = &num[2];// arvo 0x003B

*(osoitin_msg) = msg[0]; // arvo 'A'
*(osoitin_msg+1) = msg[1]; // arvo 'B' 
*(osoitin_msg+2) = msg[2]; // arvo 'C'

*(osoitin_num) = num[0]; // arvo 1
*(osoitin_num+1) = num[1]; // arvo 2
*(osoitin_num+2) = num[2]; // arvo 3

int16_t *osoitin; 

// Tämä lause tulostaa num-taulukon alkiot osoittimia käyttäen
for (osoitin = num; osoitin < num+3; osoitin++) {
   printf("%d\n", *osoitin);
} 

void vaihda(int8_t local_a, int8_t local_b); // prototyyppi

int main() {
   int8_t main_a = 14;
   int8_t main_b = 68;
   printf("Ennen: main_a=%d ja main_b=%d\n", main_a, main_b);
   vaihda(main_a, main_b);
   printf("Jälkeen: main_a=%d ja main_b=%d\n", main_a, main_b);
}

void vaihda(int8_t local_a, int8_t local_b) {
   int8_t temp = local_a;
   local_a = local_b;
   local_b = temp;
}

Ennen: main_a=14 ja main_b=68
Jälkeen: main_a=14 ja main_b=68

void vaihda(int8_t *a, int8_t *b); // prototyyppi

int main() {
   int8_t main_a = 14;
   int8_t main_b = 68;

   printf("Ennen: main_a=%d ja main_b=%d\n", main_a, main_b);

   // Argumentiksi muuttjien arvon sijasta niiden osoitteet!
   // Huomaa &-operaattori
   vaihda(&main_a, &main_b); 

   printf("Jälkeen: main_a=%d ja main_b=%d\n", main_a, main_b);
}

void vaihda(int8_t *local_a, int8_t *local_b) {
   int8_t temp = *local_a; // talleta a:n muistipaikan arvo
   *local_a = *local_b; // sijoita b:n muistipaikan arvo a:n muistipaikan arvoon
   *local_b = temp; // sijoita a:n muistipaikan arvo b:n muistipaikkaan
}

int8_t *local_a = &main_a;
int8_t *local_b = &main_b;

Ennen: main_a=14 ja main_b=68
Jälkeen: main_a=68 ja main_b=14

// prototyyppi
void kasittele(char txt[2000]);

int main() {
   char essee[2000];
   kasittele(essee);   
   return 0;
}

void kasittele(char txt[2000]) {
   // koodia ...
}

void kasittele(char *txt, int16_t txt_len);

int main() {
   char essee[2000];
   kasittele(essee,2000);   
   return 0;
}

void vaihda(int8_t *a, int8_t *b) {
   int8_t temp = *a;
   *a = *b;
   *b = temp;
}

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

int main() {

  char nimi[] = "Judge Dredd";
  printf("Nimen %s pituus on %d\n",nimi, strlen(nimi));

  return 0;
}

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

int main () {
  char str[] = "Alpha,Bravo,Charlie,Delta"; // Tutkittava merkkijono
  const char sep[] = ",";  // Erotin
  char *token; // Paikkamerkki
   
  /* Erota ensimmäinen osa */
  token = strtok(str, sep);
   
  /* Erota loput osat */
  while( token != NULL ) {
    printf("%s\n",token);

    /* Kutsutaan samaa funktiota uudelleen */
    token = strtok(NULL, sep);
    }
   
  return(0);
}