Практически во всех серьезных программах используют подпрограммы. В языках С/С++ подпрограммы принято называть функциями. И эта концепция настолько развита, что программа начинает выполняться с основной функции, называемой "main", которая обязательно должна присутствовать в программе. Кроме main программист может создавать другие функции, с различными именами.
Функции взаимодействуют с вызывающими их программными единицами (которые могут быть основной функцией - main, либо, в свою очередь, являться подпрограммами-функциями ) посредством обмена параметрами (аргументами) и возвращаемыми значениями. 
Объявляют функции так: 
<тип функции> имя_функции (<список аргументов с указанием их типов>)
{
<тело подпрограммы-функции>;
<return(<возвращаемое значение>)>
}
Приведем пример использования функции в программе, вычисляющей n-факториал(n!): 

#include <stdio.h>
/* Если компилятор ( или преподаватель) будет ругаться, что не описан прототип функции, напишите: int fu(int); Это означает, что мы используем целую функцию fu, имеющую один целый аргумент */
main()     // функция main, с нее начинается выполнение программы
{
int n;
printf(" n="); scanf("%d", &n);     // считываем вводимое пользователем значение n
printf(" %d! = %d", n, fu(n));     /* пишем возвращаемое функцией fu(n) значение n-факториала */
}
int fu(int n)     // описываем целую функцию fu, имеющую целый аргумент n
{
int i, f;
f=1;
for (i=1; i<=n; i++ ) f=f*i;     // в цикле вычисляем факториал, f
return(f);                                // функция возвращает значение факториала
}

Заметим, что если <тип функции> определен как "void", то функция не возвращает значение: обмен данными с вызывающими функциями происходит через передаваемые параметры (аргументы). Оператор "return(что-то)" в такой функции, соответственно, не пишется.
Пример использования такой функции, вычисляющей n-факториал(n!): 

#include <stdio.h>
void fu(int, int*);
main()
{
int n, fuktorial;
printf(" n="); scanf("%d", &n);
fu(n, &fuktorial);     // обращение к функции fu с n и адресом: &fuktorial 
printf(" %d! = %d", n, fuktorial);
}
void fu(int n, int *f)
{
int i;
*f=1;         // тому, что находится по адресу, записанному в f, присваиваем 1
for (i=1; i<=n; i++ ) *f=*f*i;
}
Приведем некоторые пояснения к программе. 
В строке fu(n, &fuktorial); происходит обращение к функции fu. При этом в качестве параметров указаны: значение переменной n, и адрес переменной fuktorial, т.е. &fuktorial. Это сделано потому, что, всилу особенностей языка С, функция не может напрямую изменить значение fuktorial, т.к. получает в свое распоряжение только его копию(!), и с этой копией она может сделать все, что пожелает, но по возвращении обратно, в вызывающую программу, значение fuktorial останется прежним.(Конечно, где-то в памяти будет валяться измененная копия...но где?). Поэтому вместо значения fuktorial функции передается его адрес: &fuktorial. И далее, функция оперирует не с самой переменной, а с тем, что находится по адресу f, для чего прибегают к приему косвенной адресации : *f (обозначает "то, что находится в памяти по адресу, находящемуся в f").

В языке С разрешена рекурсия- прием программирования, когда в функции встречается вызов этой же функции. Приведем пример вычисления факториала в функции, использующей рекурсивный вызов: 

#include <stdio.h>
main()
{
int n;
printf(" n="); scanf("%d", &n);
printf(" %d! = %d", n, fu(n));
}
int fu(int n)
{
if (n==1) return(1);             // возвращает 1, если n =1
if (n>1) return(n*fu(n-1));  // вот она, рекурсия (fu возвращает n!, если n >1)
return(-1);                           // возвращает -1, если n <=0
}

                   <<ранее             к оглавлению       далее>>

                      то же на Fortran                        то же на Basic                 то же на Pascal