Czy lepiej jest dużo małych funkcji czy kilka większych?

Tak jak w temacie. Czy program działa szybciej gdy mamy przykładowo, jedne zadanie wykonane kilkoma malutkimi funkcjami, czy jedną większą funkcją. Chyba że to nie ma znaczenia :)

Każda normalna funkcja wymaga jej uruchomienia i przekazania argumentów, jednak wg. mnie warto rozbijać kod na mniejsze części, aby zwiększyć jego czytelność.

nie odczujesz roznicy

Rozbijanie dużych funkcjonalności na pod-funkcje jest bardzo pomocne w późniejszym rozumowaniu kodu. Tylko trzeba pamiętać by nie było udziwnień, polecam stosowania reguł tworzenia oprogramowania DRY and KISS

Link: http://www.imagineblog.pl/dry-kiss-czyli-trudna-sztuka-dobrego-programowania/

Kompilator zapewne i tak wyinlineuje* większość z tych funkcji, więc narzutu nie powinno być żadnego, za to jak koledzy wyżej pisali: czytelność wzrośnie niesamowicie.

*ma ktoś jakiś polski odpowiednik na to słowo?

Każda normalna funkcja wymaga jej uruchomienia i przekazania argumentów

O RLY?

#include <cstdio>

void print5(int a) {
  printf("%d", 5 + a);
}

void print7(int a) {
  printf("%d", 7 + a);
}

void print9(int a) {
  printf("%d", 9 + a);
}

int main() {
  print5(1);
  print7(2);
  print9(3);
}

To wytlumacz mi czemu powyzsze funkcje nie sa normalne, bo kompilator wyrzuca cos takiego:

.LC0:
	.string	"%d"
print5(int):
	lea	esi, [rdi+5]
	xor	eax, eax
	mov	edi, OFFSET FLAT:.LC0
	jmp	printf
print7(int):
	lea	esi, [rdi+7]
	xor	eax, eax
	mov	edi, OFFSET FLAT:.LC0
	jmp	printf
print9(int):
	lea	esi, [rdi+9]
	xor	eax, eax
	mov	edi, OFFSET FLAT:.LC0
	jmp	printf
main:
	sub	rsp, 8
	mov	esi, 6
	mov	edi, OFFSET FLAT:.LC0
	xor	eax, eax
	call	printf
	mov	esi, 9
	mov	edi, OFFSET FLAT:.LC0
	xor	eax, eax
	call	printf
	mov	esi, 12
	mov	edi, OFFSET FLAT:.LC0
	xor	eax, eax
	call	printf
	xor	eax, eax
	add	rsp, 8
	ret

A ja tu ani ich wywolywania, ani przekazywania argumentow nie widze. :(

Prosta zasada: funkcja powinna robić jedną rzecz. Np. zapisz x do y, odczytaj a z urządzenia x, wyświetl kontener typu x itd.
Jeśli funkcja ma wiele czynności do wykonania to trzeba szukać rozwiązań dodatkowych. Np. wszystkie funkcje niższego rzędu przenieść do pod-funkcji właściwych lub podzielić funkcję na logiczne etapy.

"Mega-funkcja" jest trudna do nadpisana w klasach-potomkach, gdy trzeba wymienić niektóre elementy ale zachować ten sam porządek wywołania.

A co do polskiej wersji sformułowania "to inline" to mi najbardziej odpowiadana "inline'ować".

jakies czesci ms zaoszczedzisz majac wszystko w jednej funkcji

@ vpiotr konkretny przypadek. Bez wstawki asm, juz nie pamietam ale bylo setne albo 0,1 ms wolniej. Kod wykonywany jest co 16 ms wiec chcyba ma jakies tam znaczenie. Delphi XE5 albo XE 7 tez jzu nie pamietam -.-

procedure TGrafika.Wyswietl(const xPoczatek, yPoczatek: integer; const xyKolor: TXYKolor);
const
  adresKolor: cardinal = $006CF4AC;
  adres: cardinal = $004E1D20;
var
  x, y: integer;
  xEkran, yEkran: integer;
  kolor: byte;
begin
  for x := 0 to Length(xyKolor) - 1 do
    for y := 0 to Length(xyKolor[0]) - 1 do
      if xyKolor[x, y] <> 0 then // brak czarnego
      begin
        kolor := xyKolor[x, y];
        xEkran := x + xPoczatek;
        yEkran := y + yPoczatek;
        asm
          pushad
          mov   cl, kolor
          mov   eax, adresKolor
          mov   byte ptr ds:[eax], cl
          push  1
          push  1
          push  yEkran
          push  xEkran
          call  dword ptr [adres]
          popad
        end;
      end;
end;