Comment afficher les nombres de 1 à 1000 en C ou C++ sans boucle ni structure conditionnelle ?

En développement les boucles permettent de faire une action plusieurs fois. Voici comment afficher les nombres de 1 à 1000 en C ou C++ sans boucle ni structure conditionnelle.

En développement les boucles permettent de faire une action plusieurs fois de suite. On s'en sert notamment pour effectuer des traitements sur des enregistrements de base de données, des tableaux. Pour afficher les nombres allant de 1 à 1000, on utiliserait logiquement une boucle. Il est cependant possible de passer par d'autres méthodes en C++ ou en C++.

En C++, les templates permettent de définir des fonctions génériques qui sont réutilisables à volonté. On peut utiliser les templates pour définir une fonction qui s'appelle avec comme paramètre le nombre précédent puis affiche le nombre passé en paramètre. Cela s'appelle une fonction récursive. Ensuite, pour que cette récursivité s'arrête, on définit comme template la fonction d'affichage ayant comme paramètre le nombre 1 qui l'affichera sans appeler d'autres fonctions :

#include <iostream>
template<int N>
struct NumberGeneration{
 static void out(std::ostream& os)
 {
 NumberGeneration<N-1>::out(os); //On appelle la même fonction pour le nombre précédent.
 os << N << std::endl; //On affiche le nombre passé en paramètre.
 }
};
template<>
struct NumberGeneration<1>{
 static void out(std::ostream& os)
 {
 os << 1 << std::endl; //On affiche le nombre 1, sans appel supplémentaire.
 }
};
int main(){
 NumberGeneration<1000>::out(std::cout);
}

En C, il est également possible d'effectuer des traitements récursifs sans une boucle (voir aussi notre autre astuce la plus populaire sur C : Comme initialiser un tableau en C en attribuant une valeur identique à chaque élément ?).
On peut pour cela utiliser les pointeurs et un peu d'arithmétique. En utilisant la fonction main, il est possible d'afficher un nombre. Les pointeurs permettent d'effectuer des opérations sur les fonctions. On peut ajouter une méthode ou en enlever une. En couplant ces opérations à un calcul autour du nombre passé en paramètre, on obtient une directive qui appelle la fonction main() avec le nombre suivant jusqu'au nombre 1000. Une fois le nombre 1000 atteint, c'est la fonction exit() qui est appelée, mettant fin au code :

#include <stdio.h>
#include <stdlib.h>
void main(int j) {
 printf(%d , j);
 (&main + (&exit - &main)*(j/1000))(j+1);
}}

Une dernière solution, en C standard, consiste à utiliser un tableu dans la fonction affichant le nombre. Celui-ci contiendra en premier la fonction d'affichage, en deuxième la fonction exit(). Il suffit ensuite de diviser le nombre en paramètre par 1000 quand on appelle le tableau. La fonction s'appellera de manière récursive jusqu'à atteindre le nombre 1000 et le code s'arrêtera :

#include <stdio.h>
#include <stdlib.h>
void f(int j)
{
 static void (*const ft[2])(int) = { f, exit };

printf(%d , j);
 ft[j/1000](j + 1);
}
int main(int argc, char *argv[])
{
 f(1);
}