Funkcje - podstawy

Można powiedzieć, że w języku C program jest zbiorem definicji zmiennych i funkcji. Komunikacja pomiędzy funkcjami odbywa się za pośrednictwem argumentów wywołania funkcji i wartości zwracanych przez funkcje, a także za pomocą zmiennych zewnętrznych (globalnych). Definicja funkcji ma następującą postać

wartoscZwracana NazwaFunkcji(deklaracje parametrow)
{
  deklaracje
  
  instrukcje
}

• W pliku źródłowym funkcje moogą występować w dowolnej kolejności a program można podzielić między kilka plików źródłowych pod warunkiem, że żadna z funkcji nie zostanie podzielona.
• Wywołana funkcja przekazuje wartość do miejsca wywołania dzięki instrukcji return
• Funkcja wywołująca może zignorować zwracaną wartość.
• Instrukcja return nie musi zawierać wyrażenia. W takiej sytuacji do miejsca wywołania nie przekazuje się żadnej wartości.
• Sterowanie wraca bez wartości wówczas gdy wykonywanie funkcji zakończy się po osiągnięciu nawiasu klamrowego zamykającego funkcję.
• Pominięcie w definicji typu powrotu przez domniemanie oznacza, że funkcja zwraca wartość typu int

#include <stdio.h>

int Max(int x, int y)
{
  if (x>y)
    return x;
  return y;
  // mozna krocej
  //return (x>y)?x:y;
  //
}

int main(void)
{
  int x=10, y=12;
  int a=45, b=75;
  
  printf("Max z %d i %d to %d\n",x,y,Max(x,y));
  printf("Max z 1 i 7 to %d\n",Max(1,7));
  printf("Max z %d i %d to %d\n",a,b,Max(a,b));
  
  return 0;
}

Max z 10 i 12 to 12
Max z 1 i 7 to 7
Max z 45 i 75 to 75

Analizując powyższy przykład warto zauważyć, że

• Główna część programu, którą wpisujemy w main nie jest niczym innym jak funkcją; main to specjalna funkcja, od której rozpoczyna się wykonanie programu.
• Jeśli nie przekazujemy do funkcji żadnych argumentów, lub jeśli funkcja nic nie zwraca to jako typ zwracanej wartości piszemy void
• Funkcja main w przypadku poprawnego zakończenia zwraca wartość zero.

wartoscZwracana NazwaFunkcji (deklaracje parametrow);

Globalnie i lokalnie

• Program w języku C to zbiór obiektów (zmiennych i funkcji) zewnętrznych (globalnych).
• Wewnętrzne mogą być tylko zmienne. Zmienną wewnętrzną nazwiemy każdą zmienną zadeklarowaną wewnątrz funkcji; będziemy o nich także mówić: zmienne automatyczne.
• Zmienne zewnętrzne definiuje się poza wszystkimi funkcjami są więc one dostępne dla wszystkich funkcji.
• W języku C nie dopuszcza się definiowania funkcji wewnątrz innej funkcji.
• Zmienne zewnęrzne umożliwiają prostą komunikację pomiędzy funkcjami. Zmienne globalne istnieją przez cały czas działania programu.
• Jeśli nie podano inaczej, zmienne zewnętrzne są zawsze inicjalizowane zerami, natomiast wartości dla zmiennych automatycznych są nieokreślone (przypadkowe).
• Mówiąc o zasięgu nazwy określać będziemy tą część programu wewnątrz której można danej nazwy użyć.
• Zmienne lokalne o tej samej nazwie, które występują w różnych funkcjach, nie są ze sobą związane w zadne sposób. Podobnie wygląda sytuacja z parametrami funkcji, które nie są niczym innym jak zmiennymi lokalnymi (o zasięgu ograniczonym tylko do danej funkcji).

#include <stdio.h>

int x; //zmienna globalna
int y; //zmienna globalna
int z=0; //zmienna globalna

void Change(int i)//i jest lokalne w tej funkcji
{
  i=i*i;
  z+=1;
}

void Swap1(int i, int y)//i i y sa lokalne w tej funkcji
{
  int temp;//zmienna lokalna; jej zasieg to cialo funkcji swap1
  
  temp=i;
  i=y;
  y=temp;
  z+=1;
}

void Swap2(void)
{
  int temp;//zmienna lokalna; jej zasieg to cialo funkcji swap2
  
  temp=x;
  x=y;
  y=temp;
  z+=1;
}

int main(void)
{
  x=2;
  y=7;
  
  printf("x=%d, y=%d z=%d\n",x,y,z);
  Swap1(x,y);
  printf("x=%d, y=%d z=%d\n",x,y,z);
  Swap2();
  printf("x=%d, y=%d z=%d\n",x,y,z);
  Change(x);
  printf("x=%d z=%d\n",x,z);
}

x=2, y=7 z=0
x=2, y=7 z=1
x=7, y=2 z=2
x=7 z=3

Przyglądając się ostaniemu przykładowi zaobserwować można jak zachowują się argumenty przekazywane do funkcji. Otóż funkcja swap1, mimo iż chce, nie może zmienić ich wartości; pracuje ona na ich lokalnej kopii. Taki sposób przekazywnia argumentów nazywamy przekazywaniem przez wartość.

Zmienne statyczne

Deklarację/definicję zmiennej czy funkcji można poprzedzić słowem kluczowym static

• Jeśli dotyczyć ono będzie zmiennej zewnętrznej (globalnej) czy funkcji to wówczas ta zmienna czy funkcja będzie widoczna jedynie w pliku w którym została zadeklarowana (o podziale programu na wiele plików będzie w dalszej części wykładu).
• Jeśli dotyczyć ono będzie zmiennej wewnętrznej wówczas taka zmienna nie zniknie pomiędzy wywołaniami tej samej funkcji. Wewnętrzne zmienne statyczne można uważać za prywatną, stałą pamięć wewnątrz pojednyńczej funkcji (patrz przykład poniżej).

#include <stdio.h>

void funkcja(void)
{
  int x=0;
  static int y=0;
  
  printf("x=%d, y=%d\n",x,y);
  x++;
  y++;
}
int main(void)
{
  funkcja();
  funkcja();
  funkcja();
  return 0;
}

x=0, y=0
x=0, y=1
x=0, y=2

Preprocesor - makroinstrukcje

Preprocesor jest programem, który poddaje tekst źródłowy naszego programu pewnym przkształceniom zanim rozpocznie się właściwy proces kompilacj (patrz rysunek poniżej)

Najprostszy rodzaj makroinstrukcji ma postać

#define NAZWA tekstZastepujacy

#undef nazwaMakroinstrukcji

#include <stdio.h>

#define OK 0
#define LINIA printf("==============================\n");
#define ERROR(tekst) printf("Blad:"#tekst"\n");
#define BIGERROR(tekst) ERROR(tekst) printf("Prosze zakonczyc prace\n");
#define TEST1 printf("Ble, ble...\n");
#define TEST2(tekst) tekst##1

int main(void)
{
  LINIA
  ERROR(To jest kontrolowany blad)
  LINIA
  BIGERROR(Kontrolowany bug numer 2)
  LINIA
  TEST2(TEST)
  
  return OK;
}

==============================
Blad:To jest kontrolowany blad
==============================
Blad:Kontrolowany bug numer 2
Prosze zakonczyc prace
==============================
Ble, ble...

#include

Każdy wiersz źródłowy programu postaci

#include "nazwaPliku"

#include <nazwaPliku>

#include <stdio.h>

int main(void)
{
  #include "wypisz.txt"
  return 0;
}

printf("Tekscik testowy\n");

Tekscik testowy

Kompilacja warunkowa

Za pomocą instrukcji warunkowych wykonywanych w fazie preprocesora można wybiórczo włączać do programu pewne fragmenty kodu. W tym celu wykorzystywać będziemy instrukcje analogiczne do poznanej już if-else, ale dla odróżnienia poprzedzając słowa kluczowe snakiem #

#if (wyrazenie1)
  instrukcje
#elif (wyrazenie2)
  instrukcje
#elif (wyrazenie3)
  instrukcje
#else
  instrukcje
#endif

defined (NAZWA)

#include <stdio.h>

#define TAK 1
#define NIE 0
#define ZONA 1
#define ZALUJE NIE

void funkcjaZwierzenia(void)
{
  #if defined(ZONA)
    printf("Mam zone...\n");
    printf("Porozmawiajmy o Niej troche...\n");
    #if ZALUJE
      printf("Wcale nie jest mi z Nia dobrze!\n");
    #else
      printf("Coz to za cudowna Kobieta!\n");
    #endif
  #else
    printf("Nie znam pojecia ZONA!\n");
  #endif
}

void funkcjaSamooceny(void)
{
  #ifdef TAK
    printf("Znam makro TAK, ktore ma wartosc %d\n",TAK);
  #endif
  
  //#define JAKIES 15
  
  #ifndef JAKIES
    #define JAKIES 135
  #endif
  
  printf("Znam makro JAKIES, ktore ma wartosc %d\n",JAKIES);
}
  
int main(void)
{
  funkcjaZwierzenia(); 
  funkcjaSamooceny();
}

Mam zone...
Porozmawiajmy o Niej troche...
Coz to za cudowna Kobieta!
Znam makro TAK, ktore ma wartosc 1
Znam makro JAKIES, ktore ma wartosc 135

Rekursja vs. iteracja

Tutaj powinno być wyjaśnienie co to jest rekursja (rekurencja) i co to jest iteracja. Nie mam jednak zdrowia tego pisać, więc powiem tak:

• Iteracja czyli wielokrotne powtarzanie (w pętli) zadanego fragmentu kodu.
• Rekursja czyli wywoływanie funkcji przez samą siebie lub inaczej definiowanie funkcji przez użycie w definicji tejże funkcji czyli definiowaniu obiektu w oparciu o ten obiekt.

• Iteracyjną: silnia z n jest to iloczyn liczb całkowitych od 1 do n.
Rekursywną: silnia z n jest to iloczyn n * silnia z (n-1).

double SilniaI(int n)
{
  int i=1;
  double s=1;
    
  for(;s=s*i,i

double SilniaR(int n)
{
  if (n==0)
    return 1;
    
  return n*SilniaR(n-1);
}