C++ - Historique des versions

Cedric.holocher : /* Objets */ exo inf443

2024-03-19T09:26:57Z

Objets : exo inf443

← Version précédente		Version du 19 mars 2024 à 11:26
Ligne 220 :		Ligne 220 :
	* redéfinissions des constructeurs, constructeur par défaut, de copie ou de move		* redéfinissions des constructeurs, constructeur par défaut, de copie ou de move
	* redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...		* redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...

			Pour s'exercer à la création de structure, un mini-TD d'inf443 est efficace : [https://imagecomputing.net/course/2023_2024/inf443/lab/content/03/a_cpp_classes/index.html]

	==Eléments utiles du standard==		==Eléments utiles du standard==

Cedric.holocher : /* Objets */

2024-03-05T17:09:31Z

Objets

← Version précédente		Version du 5 mars 2024 à 19:09
Ligne 181 :		Ligne 181 :

	const rationnel r3 = rationnel{r1.b, 2}; // construit r3 = r1.b/2		const rationnel r3 = rationnel{r1.b, 2}; // construit r3 = r1.b/2
	return 0;		return 0; // à la sortie de la fonction, r3, par_defaut2, par_defaut1, r1 sont détruits dans cet ordre
	} // à la sortie de la fonction, r3, par_defaut2, par_defaut1, r1 sont détruits dans cet ordre		}

	</source>		</source>

Cedric.holocher : /* Fonction main() et éléments */

2024-03-05T17:09:05Z

Fonction main() et éléments

← Version précédente		Version du 5 mars 2024 à 19:09
Ligne 88 :		Ligne 88 :
	Comme dans de nombreux langages, on utilise les construction :		Comme dans de nombreux langages, on utilise les construction :

	* <code>if(cond) ; else if(cond2) ; else</code>		* <code>if(cond) { code } ; else if(cond2) { code } ; else { code }</code>
	* <code>while(cond)</code>		* <code>while(cond) { boucle }</code>
	* <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>		* <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>
	* <code>for(auto element : container) { boucle }</code>.		* <code>for(auto element : container) { boucle }</code>.

Cedric.holocher : /* Fonction main() et éléments */

2024-03-05T17:08:26Z

Fonction main() et éléments

← Version précédente		Version du 5 mars 2024 à 19:08
Ligne 86 :		Ligne 86 :
	La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.		La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.

	Comme dans de nombreux langages, on utilise les construction <code>if(cond) ; else if(cond2) ; else</code>, <code>while(cond)</code>, <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>, <code>for(auto element : container) { boucle }</code>.		Comme dans de nombreux langages, on utilise les construction :

			* <code>if(cond) ; else if(cond2) ; else</code>
			* <code>while(cond)</code>
			* <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>
			* <code>for(auto element : container) { boucle }</code>.

	Les fonctions s'écrivent :		Les fonctions s'écrivent :

Cedric.holocher : /* Fonction main() */

2024-03-05T17:07:42Z

Fonction main()

← Version précédente		Version du 5 mars 2024 à 19:07
Ligne 82 :		Ligne 82 :
	Pour toutes vos question, [https://en.cppreference.com/w/cpp/language cppreference.com] vous répondra avec précision. Hélas, il ne s'agit pas d'un tuto. Nous explorerons ici quelques concepts.		Pour toutes vos question, [https://en.cppreference.com/w/cpp/language cppreference.com] vous répondra avec précision. Hélas, il ne s'agit pas d'un tuto. Nous explorerons ici quelques concepts.

	==Fonction main()==		==Fonction main() et éléments==

	La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.		La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.

			Comme dans de nombreux langages, on utilise les construction <code>if(cond) ; else if(cond2) ; else</code>, <code>while(cond)</code>, <code>for(std::size_t i = 0; i < MAX_DE_I; i++) { boucle }</code>, <code>for(auto element : container) { boucle }</code>.

			Les fonctions s'écrivent :

			<source lang="c++">

			auto doubler(int x) -> int { return 2 * x ; }
			int doubler_encore(int x) { return 2 * x ; }

			// fonction lambda, compacte pour certains usages "fonctionnels"
			auto lambda_qui_double = [](int x){ return 2 * x ; };
			</source>

	==Variables==		==Variables==

Cedric.holocher : /* Langage */

2024-03-05T17:01:41Z

Langage

← Version précédente		Version du 5 mars 2024 à 19:01
Ligne 101 :		Ligne 101 :
	</source>		</source>

	Une variable peut être ~~constance~~ <code lang="c++"> const int x = 13; </code>		Une variable peut être constante <code lang="c++"> const int x = 13; </code>

	Une variable peut être une référence à une autre (qui doit vivre tant que la référence existe !!!). C'est très utile pour prendre comme paramètre un type lourd		Une variable peut être une référence à une autre (qui doit vivre tant que la référence existe !!!). C'est très utile pour prendre comme paramètre un type lourd

Cedric.holocher : &

2024-03-05T17:01:06Z

← Version précédente		Version du 5 mars 2024 à 19:01
Ligne 85 :		Ligne 85 :

	La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.		La fonction <code>main()</code> ou <code>main(int argc, char** argv)</code> est le point d'entrée du programme.

			==Variables==

			Le C++ est au typage fort (contrairement à son ancêtre le C). Une variable est déclarée avec son type ou celui-ci est déduit.

			<source lang="c++">
			// une fonction
			auto treize() -> int { return 13; }

			int main() {
			int a = 13;
			int b = treize();
			auto c = treize();
			}
			</source>

			Une variable peut être constance <code lang="c++"> const int x = 13; </code>

			Une variable peut être une référence à une autre (qui doit vivre tant que la référence existe !!!). C'est très utile pour prendre comme paramètre un type lourd

			<source lang="c++">
			// une fonction
			auto treize() -> int { return 13; }

			int main() {
			int a = 13;
			int& ref1 = a;
			auto& ref2 = a;
			auto const& const_ref = a;
			}

			// évite la copie de "entiers" en prenant une référence !
			auto sum(std::vector<int> const& entiers) -> int { ... }
			</source>


	==Entrées-sorties console==		==Entrées-sorties console==

Cedric.holocher : /* Type standarts utiles */

2024-03-05T16:53:30Z

Type standarts utiles

← Version précédente		Version du 5 mars 2024 à 18:53
Ligne 168 :		Ligne 168 :
	* redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...		* redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...

	==~~Type standarts~~ utiles==		==Eléments utiles du standard==

	===Conteneurs===		===Conteneurs===
Ligne 212 :		Ligne 212 :

	</source>		</source>

			==Algorithmes==

			De nombreux algorithmes classiques sont implémentés de manière fonctionnelle et générique : [https://en.cppreference.com/w/cpp/algorithm]

Cedric.holocher : /* Type utiles */

2024-03-05T16:50:26Z

Type utiles

@@ Ligne 168 : / Ligne 168 : @@
 * redéfinissions des opérateurs arithmétiques, d'appel, d'indexation...
-==Type utiles==
+==Type standarts utiles==
 ===Conteneurs===
@@ Ligne 181 : / Ligne 181 : @@
 ===Vues sur une partie du conteneur (slice)===
 * std::string_view (nécessite C++17)
 * std::span<type>  (nécessite C++20)

Cedric.holocher le 5 mars 2024 à 16:39

2024-03-05T16:39:59Z

Voir les différences

C++ - Historique des versions

Cedric.holocher : /* Objets */ exo inf443

Cedric.holocher : /* Objets */

Cedric.holocher : /* Fonction main() et éléments */

Cedric.holocher : /* Fonction main() et éléments */

Cedric.holocher : /* Fonction main() */

Cedric.holocher : /* Langage */

Cedric.holocher : &

Cedric.holocher : /* Type standarts utiles */

Cedric.holocher : /* Type utiles */

Cedric.holocher le 5 mars 2024 à 16:39

Cedric.holocher : /* Objets */ exo inf443

Cedric.holocher : /* Objets */

Cedric.holocher : /* Fonction main() et éléments */

Cedric.holocher : /* Fonction main() et éléments */

Cedric.holocher : /* Fonction main() */

Cedric.holocher : /* Langage */

Cedric.holocher : &

Cedric.holocher : /* Type standarts utiles */

Cedric.holocher : /* Type utiles */