Types de données
Entier (Integer)
#include <stdio.h>
int main() {
int entier = 10;
println("%d\n", entier);
return 0;
}
content_copy
#include <iostream>
int main() {
int entier = 10;
std::cout << "entier: " << entier << std::endl;
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
int entier = 10;
System.out.println("entier: " + entier);
}
}
content_copy
<?php
$entier = 10;
echo "entier: $entier\n";
content_copy
entier = 10
print(f"entier: {entier}")
content_copy
let entier = 10;
console.log("entier:", entier);
content_copy
#!/bin/bash
entier=10
echo "entier: $entier"
content_copy
Flottant (Float)
#include <stdio.h>
int main() {
float flottant = 3.14f; // Flottant (simple précision)
printf("flottant: %f\n", flottant);
return 0;
}
content_copy
#include <iostream>
int main() {
float flottant = 3.14f; // Flottant (simple précision)
std::cout << "flottant: " << flottant << std::endl;
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
float flottant = 3.14f; // Flottant (simple précision)
System.out.println("flottant: " + flottant);
}
}
content_copy
<?php
$flottant = 3.14; // Flottant (PHP utilise le double)
echo "flottant: $flottant\n";
content_copy
flottant = 3.14 # Flottant (double précision en Python)
print(f"flottant: {flottant}")
content_copy
let flottant = 3.14; // Flottant (JavaScript utilise des doubles)
console.log("flottant:", flottant);
content_copy
#!/bin/bash
flottant=3.14 # Flottant (Bash n'a pas vraiment de type float)
echo "flottant: $flottant"
content_copy
Caractère (Char)
#include <stdio.h>
int main() {
char caractere = 'A'; // Caractère
printf("caractere: %c\n", caractere);
return 0;
}
content_copy
#include <iostream>
int main() {
char caractere = 'A'; // Caractère
std::cout << "caractere: " << caractere << std::endl;
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
char caractere = 'A'; // Caractère
System.out.println("caractere: " + caractere);
}
}
content_copy
<?php
$caractere = 'A'; // Caractère (pas de type 'char' en PHP)
echo "caractere: $caractere\n";
content_copy
caractere = 'A' # Caractère (Python utilise str pour cela)
print(f"caractere: {caractere}")
content_copy
let caractere = 'A'; // Caractère (en fait une chaîne de longueur 1)
console.log("caractere:", caractere);
content_copy
#!/bin/bash
caractere="A" # Caractère
echo "caractere: $caractere"
content_copy
String
#include <stdio.h>
int main() {
char string[] = "Bonjour"; // Chaîne de caractères
printf("string: %s\n", string);
return 0;
}
content_copy
#include <iostream>
#include <string>
int main() {
std::string string = "Bonjour"; // Chaîne de caractères
std::cout << "string: " << string << std::endl;
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
String string = "Bonjour"; // Chaîne de caractères
System.out.println("string: " + string);
}
}
content_copy
<?php
$string = "Bonjour"; // Chaîne de caractères
echo "string: $string\n";
?>
content_copy
string = "Bonjour" # Chaîne de caractères
print(f"string: {string}")
content_copy
let string = "Bonjour"; // Chaîne de caractères
console.log("string:", string);
content_copy
#!/bin/bash
string="Bonjour" # Chaîne de caractères
echo "string: $string"
content_copy
Double
#include <stdio.h>
int main() {
double number = 10.123456789; // Double
printf("number: %lf\n", number);
return 0;
}
content_copy
#include <iostream>
int main() {
double number = 10.123456789; // Double
std::cout << "number: " << number << std::endl;
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
double number = 10.123456789; // Double
System.out.println("number: " + number);
}
}
content_copy
<?php
$number = 10.123456789; // Double
echo "number: $number\n";
?>
content_copy
number = 10.123456789 # Double (en Python, float représente double précision)
print(f"number: {number}")
content_copy
let number = 10.123456789; // Double (JavaScript utilise number pour float et double)
console.log("number:", number);
content_copy
#!/bin/bash
number=10.123456789 # Bash ne gère pas nativement les nombres à virgule flottante
echo "number: $number"
content_copy
Boolean
#include <stdio.h>
#include <stdbool.h> // Bibliothèque pour les booléens en C
int main() {
bool isTrue = true; // Boolean
if (isTrue) {
printf("isTrue: %d\n", isTrue);
}
return 0;
}
content_copy
#include <iostream>
#include <stdbool.h> // Bibliothèque pour les booléens en C++
int main() {
bool isTrue = true; // Boolean
if (isTrue) {
std::cout << "isTrue: " << isTrue << std::endl;
}
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
boolean isTrue = true; // Boolean
if (isTrue) {
System.out.println("isTrue: " + isTrue);
}
}
}
content_copy
<?php
$isTrue = true; // Boolean
if ($isTrue) {
echo "isTrue: $isTrue\n";
}
?>
content_copy
isTrue = True # Boolean
if isTrue:
print(f"isTrue: {isTrue}")
content_copy
let isTrue = true; // Boolean
if (isTrue) {
console.log("isTrue:", isTrue);
}
content_copy
#!/bin/bash
isTrue=true # Boolean (simulé par des chaînes en Bash)
if [ "$isTrue" = true ]; then
echo "isTrue: $isTrue"
fi
content_copy
Les conditionnelles
#include <stdio.h>
int main() {
int x = 10;
if (x > 15) {
printf("x est supérieur à 15\n");
} else if (x == 10) {
printf("x est égal à 10\n");
} else {
printf("x est inférieur à 10\n");
}
return 0;
}
content_copy
#include <iostream>
int main() {
int x = 10;
if (x > 15) {
std::cout << "x est supérieur à 15\n";
} else if (x == 10) {
std::cout << "x est égal à 10\n";
} else {
std::cout << "x est inférieur à 10\n";
}
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
int x = 10;
if (x > 15) {
System.out.println("x est supérieur à 15");
} else if (x == 10) {
System.out.println("x est égal à 10");
} else {
System.out.println("x est inférieur à 10");
}
}
}
content_copy
<?php
$x = 10;
if ($x > 15) {
echo "x est supérieur à 15\n";
} elseif ($x == 10) {
echo "x est égal à 10\n";
} else {
echo "x est inférieur à 10\n";
}
?>
content_copy
x = 10
if x > 15:
print("x est supérieur à 15")
elif x == 10:
print("x est égal à 10")
else:
print("x est inférieur à 10")
content_copy
let x = 10;
if (x > 15) {
console.log("x est supérieur à 15");
} else if (x === 10) {
console.log("x est égal à 10");
} else {
console.log("x est inférieur à 10");
}
content_copy
#!/bin/bash
x=10
if [ "$x" -gt 15 ]; then
echo "x est supérieur à 15"
elif [ "$x" -eq 10 ]; then
echo "x est égal à 10"
else
echo "x est inférieur à 10"
fi
content_copy
Structures linéaires
Les tableaux
#include <stdio.h>
int main() {
int arr[] = {1, 2, 3, 4, 5}; // Déclaration d'un tableau d'entiers
for (int i = 0; i < 5; i++) {
printf("arr[%d] = %d\n", i, arr[i]);
}
return 0;
}
content_copy
#include <iostream>
int main() {
int arr[] = {1, 2, 3, 4, 5}; // Déclaration d'un tableau en C++
for (int i = 0; i < 5; i++) {
std::cout << "arr[" << i << "] = " << arr[i] << std::endl;
}
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
int[] arr = {1, 2, 3, 4, 5}; // Déclaration d'un tableau en Java
for (int i = 0; i < arr.length; i++) {
System.out.println("arr[" + i + "] = " + arr[i]);
}
}
}
content_copy
<?php
$arr = array(1, 2, 3, 4, 5); // Déclaration d'un tableau en PHP
for ($i = 0; $i < count($arr); $i++) {
echo "arr[$i] = " . $arr[$i] . "\n";
}
?>
content_copy
arr = [1, 2, 3, 4, 5] # Déclaration d'un tableau (liste) en Python
for i in range(len(arr)):
print(f"arr[{i}] = {arr[i]}")
content_copy
let arr = [1, 2, 3, 4, 5]; // Déclaration d'un tableau en JavaScript
for (let i = 0; i < arr.length; i++) {
console.log("arr[" + i + "] =", arr[i]);
}
content_copy
#!/bin/bash
arr=(1 2 3 4 5) # Déclaration d'un tableau en Bash
for i in {0..4}; do
echo "arr[$i] = ${arr[$i]}"
done
content_copy
Les boucles
For
#include <stdio.h>
int main() {
for (int i = 0; i < 5; i++) {
printf("i = %d\n", i);
}
return 0;
}
content_copy
#include <iostream>
int main() {
for (int i = 0; i < 5; i++) {
std::cout << "i = " << i << std::endl;
}
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
System.out.println("i = " + i);
}
}
}
content_copy
<?php
for ($i = 0; $i < 5; $i++) {
echo "i = $i\n";
}
?>
content_copy
for i in range(5):
print(f"i = {i}")
content_copy
for (let i = 0; i < 5; i++) {
console.log("i =", i);
}
content_copy
#!/bin/bash
for i in {0..4}; do
echo "i = $i"
done
content_copy
While
#include <stdio.h>
int main() {
int i = 0;
while (i < 5) {
printf("i = %d\n", i);
i++;
}
return 0;
}
content_copy
#include <iostream>
int main() {
int i = 0;
while (i < 5) {
std::cout << "i = " << i << std::endl;
i++;
}
return 0;
}
content_copy
public class Main {
public static void main(String[] args) {
int i = 0;
while (i < 5) {
System.out.println("i = " + i);
i++;
}
}
}
content_copy
<?php
$i = 0;
while ($i < 5) {
echo "i = $i\n";
$i++;
}
?>
content_copy
i = 0
while i < 5:
print(f"i = {i}")
i += 1
content_copy
let i = 0;
while (i < 5) {
console.log("i =", i);
i++;
}
content_copy
#!/bin/bash
i=0
while [ $i -lt 5 ]; do
echo "i = $i"
i=$((i + 1))
done
content_copy
Les fonctions
Fonctions (Void)
#include <stdio.h>
// Déclaration de la fonction
void afficherMessage() {
printf("Hello from C!\n");
}
int main() {
afficherMessage(); // Appel de la fonction
return 0;
}
content_copy
#include <iostream>
// Déclaration de la fonction
void afficherMessage() {
std::cout << "Hello from C++!" << std::endl;
}
int main() {
afficherMessage(); // Appel de la fonction
return 0;
}
content_copy
public class Main {
// Déclaration de la fonction
static void afficherMessage() {
System.out.println("Hello from Java!");
}
public static void main(String[] args) {
afficherMessage(); // Appel de la fonction
}
}
content_copy
<?php
// Déclaration de la fonction
function afficherMessage() {
echo "Hello from PHP!\n";
}
afficherMessage(); // Appel de la fonction
?>
content_copy
# Déclaration de la fonction
def afficherMessage():
print("Hello from Python!")
afficherMessage() # Appel de la fonction
content_copy
// Déclaration de la fonction
function afficherMessage() {
console.log("Hello from JavaScript!");
}
afficherMessage(); // Appel de la fonction
content_copy
#!/bin/bash
# Déclaration de la fonction
afficherMessage() {
echo "Hello from Bash!"
}
afficherMessage() # Appel de la fonction
content_copy
Fonctions
#include <stdio.h>
// Déclaration de la fonction avec retour de valeur
int somme(int a, int b) {
return a + b;
}
int main() {
int resultat = somme(5, 3); // Appel de la fonction
printf("Resultat: %d\n", resultat);
return 0;
}
content_copy
#include <iostream>
// Déclaration de la fonction avec retour de valeur
int somme(int a, int b) {
return a + b;
}
int main() {
int resultat = somme(5, 3); // Appel de la fonction
std::cout << "Resultat: " << resultat << std::endl;
return 0;
}
content_copy
public class Main {
// Déclaration de la fonction avec retour de valeur
static int somme(int a, int b) {
return a + b;
}
public static void main(String[] args) {
int resultat = somme(5, 3); // Appel de la fonction
System.out.println("Resultat: " + resultat);
}
}
content_copy
<?php
// Déclaration de la fonction avec retour de valeur
function somme($a, $b) {
return $a + $b;
}
$resultat = somme(5, 3); // Appel de la fonction
echo "Resultat: $resultat\n";
?>
content_copy
# Déclaration de la fonction avec retour de valeur
def somme(a, b):
return a + b
resultat = somme(5, 3) # Appel de la fonction
print("Resultat:", resultat)
content_copy
// Déclaration de la fonction avec retour de valeur
function somme(a, b) {
return a + b;
}
let resultat = somme(5, 3); // Appel de la fonction
console.log("Resultat:", resultat);
content_copy
#!/bin/bash
# Déclaration de la fonction avec retour de valeur
somme() {
echo $(($1 + $2)) # Retourne la somme
}
resultat=$(somme 5 3) # Appel de la fonction
echo "Resultat: $resultat"
content_copy
Les Classes
#include <stdio.h>
// Définition de la structure
typedef struct {
char nom[50];
int age;
} Personne;
// Fonction pour afficher les informations
void afficher(Personne p) {
printf("Nom: %s, Age: %d\\n", p.nom, p.age);
}
int main() {
// Création et initialisation d'une instance
Personne p;
snprintf(p.nom, sizeof(p.nom), "Alice"); // Initialisation du nom
p.age = 25; // Initialisation de l'âge
afficher(p); // Appel de la fonction afficher
return 0;
}
content_copy
#include <iostream>
// Déclaration de la classe
class Personne {
private:
std::string nom;
int age;
public:
// Constructeur
Personne(std::string n, int a) {
nom = n;
age = a;
}
// Méthode pour afficher les informations
void afficher() {
std::cout << "Nom: " << nom << ", Age: " << age << std::endl;
}
};
int main() {
// Création d'un objet de la classe
Personne p("Alice", 25);
p.afficher(); // Appel de la méthode afficher
return 0;
}
content_copy
public class Personne {
private String nom;
private int age;
// Constructeur
public Personne(String n, int a) {
nom = n;
age = a;
}
// Méthode pour afficher les informations
public void afficher() {
System.out.println("Nom: " + nom + ", Age: " + age);
}
}
public class Main {
public static void main(String[] args) {
// Création d'un objet de la classe
Personne p = new Personne("Alice", 25);
p.afficher(); // Appel de la méthode afficher
}
}
content_copy
<?php
// Déclaration de la classe
class Personne {
private $nom;
private $age;
// Constructeur
public function __construct($n, $a) {
$this->nom = $n;
$this->age = $a;
}
// Méthode pour afficher les informations
public function afficher() {
echo "Nom: " . $this->nom . ", Age: " . $this->age . "\n";
}
}
// Création d'un objet de la classe
$p = new Personne("Alice", 25);
$p->afficher(); // Appel de la méthode afficher
?>
content_copy
# Déclaration de la classe
class Personne:
def __init__(self, nom, age):
self.nom = nom
self.age = age
# Méthode pour afficher les informations
def afficher(self):
print(f"Nom: {self.nom}, Age: {self.age}")
# Création d'un objet de la classe
p = Personne("Alice", 25)
p.afficher() # Appel de la méthode afficher
content_copy
// Déclaration de la classe
class Personne {
constructor(nom, age) {
this.nom = nom;
this.age = age;
}
// Méthode pour afficher les informations
afficher() {
console.log("Nom: " + this.nom + ", Age: " + this.age);
}
}
// Création d'un objet de la classe
const p = new Personne("Alice", 25);
p.afficher(); // Appel de la méthode afficher
content_copy