fonctions<iterator>
advance
Incrémente un itérateur d'un nombre spécifié de positions.
template <class InputIterator, class Distance>
void advance(InputIterator& InIt, Distance Off);
Paramètres
InIt
Itérateur qui doit être incrémenté et qui doit être conforme aux exigences d’un itérateur d’entrée.
Off
Type intégral pouvant être converti en type de différence de l'itérateur et qui spécifie le nombre d'incréments dont la position de l'itérateur doit être avancée.
Notes
La plage doit être non-ingulaire, où les itérateurs doivent être déréférencés ou passés par la fin.
Si les InputIterator conditions sont remplies pour un type d’itérateur bidirectionnel, Off elles peuvent être négatives. S’il InputIterator s’agit d’un type d’itérateur d’entrée ou de transfert, Off doit être non négatif.
La fonction avancée a une complexité constante lorsqu’elle InputIterator répond aux exigences d’un itérateur d’accès aléatoire ; sinon, elle a une complexité linéaire et est donc potentiellement coûteuse.
Exemple
// iterator_advance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = 1; i < 9; ++i)
{
L.push_back(i);
}
list<int>::iterator LPOS = L.begin();
cout << "The list L is: ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
cout << "The iterator LPOS initially points to the first element: "
<< *LPOS << "." << endl;
advance(LPOS, 4);
cout << "LPOS is advanced 4 steps forward to point"
<< " to the fifth element: "
<< *LPOS << "." << endl;
advance(LPOS, -3);
cout << "LPOS is moved 3 steps back to point to the "
<< "2nd element: " << *LPOS << "." << endl;
}
The list L is: ( 1 2 3 4 5 6 7 8 ).
The iterator LPOS initially points to the first element: 1.
LPOS is advanced 4 steps forward to point to the fifth element: 5.
LPOS is moved 3 steps back to point to the 2nd element: 2.
back_inserter
Crée un itérateur qui peut insérer des éléments à la fin d'un conteneur spécifié.
template <class Container>
back_insert_iterator<Container> back_inserter(Container& Cont);
Paramètres
Cont
Conteneur dans lequel l’insertion de fin doit être exécutée.
Valeur de retour
back_insert_iterator associé à l’objet conteneur Cont.
Notes
Dans la bibliothèque standard C++, l’argument doit faire référence à l’un des trois conteneurs de séquence qui ont la fonction push_backmembre : deque Classe, list Classe ou vector Classe.
Exemple
// iterator_back_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <vector>
#include <iostream>
int main()
{
using namespace std;
vector<int> vec;
for (int i = 0; i < 3; ++i)
{
vec.push_back(i);
}
cout << "The initial vector vec is: ( ";
for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
{
cout << *vIter << " ";
}
cout << ")." << endl;
// Insertions can be done with template function
back_insert_iterator<vector<int> > backiter(vec);
*backiter = 30;
backiter++;
*backiter = 40;
// Alternatively, insertions can be done with the
// back_insert_iterator member function
back_inserter(vec) = 500;
back_inserter(vec) = 600;
cout << "After the insertions, the vector vec is: ( ";
for (auto vIter = vec.begin(); vIter != vec.end(); vIter++)
{
cout << *vIter << " ";
}
cout << ")." << endl;
}
The initial vector vec is: ( 0 1 2 ).
After the insertions, the vector vec is: ( 0 1 2 30 40 500 600 ).
begin
Récupère un itérateur sur le premier élément d'un conteneur spécifié.
template <class Container>
auto begin(Container& cont) `
-> decltype(cont.begin());
template <class Container>
auto begin(const Container& cont) `
-> decltype(cont.begin());
template <class Ty, class Size>
Ty *begin(Ty (& array)[Size]);
Paramètres
cont
Conteneur.
array
Tableau d'objets de type Ty.
Valeur de retour
Les deux premières fonctions de modèle retournent cont.begin(). La première fonction est non constante ; la seconde est constante.
La troisième fonction de modèle retourne array.
Exemple
Nous vous recommandons d'utiliser cette fonction de modèle à la place du membre de conteneur begin() lorsqu'un comportement plus générique est requis.
// cl.exe /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <vector>
template <typename C> void reverse_sort(C& c)
{
std::sort(std::begin(c), std::end(c), std::greater<>());
}
template <typename C> void print(const C& c)
{
for (const auto& e : c)
{
std::cout << e << " ";
}
std::cout << "\n";
}
int main()
{
std::vector<int> v = { 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1 };
print(v);
reverse_sort(v);
print(v);
std::cout << "--\n";
int arr[] = { 23, 70, 35, 106, 53, 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1 };
print(arr);
reverse_sort(arr);
print(arr);
}
11 34 17 52 26 13 40 20 10 5 16 8 4 2 1
52 40 34 26 20 17 16 13 11 10 8 5 4 2 1
--
23 70 35 106 53 160 80 40 20 10 5 16 8 4 2 1
160 106 80 70 53 40 35 23 20 16 10 8 5 4 2 1
La fonction reverse_sort prend en charge des conteneurs de tout type, outre les tableaux standard, car elle appelle la version non-membre de begin(). Codage reverse_sort pour utiliser le membre begin()de conteneur :
template <typename C>
void reverse_sort(C& c) {
using std::begin;
using std::end;
std::sort(c.begin(), c.end(), std::greater<>());
}
Ensuite, l’envoi d’un tableau à celui-ci provoque l’erreur du compilateur :
error C2228: left of '.begin' must have class/struct/union
cbegin
Récupère un itérateur const (en lecture seule) au premier élément d’un conteneur spécifié.
template <class Container>
auto cbegin(const Container& cont)
-> decltype(cont.begin());
Paramètres
cont
Un conteneur ou initializer_list.
Valeur de retour
Constante cont.begin().
Notes
Cette fonction fonctionne avec tous les conteneurs de bibliothèque C++ Standard et avec initializer_list.
Vous pouvez utiliser cette fonction membre à la place de la fonction de modèle begin() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le auto mot clé de déduction de type, comme illustré dans l’exemple suivant. Dans cet exemple, il est supposé que Container est un conteneur modifiable (autre que const) ou un initializer_list de tout type prenant en charge begin() et cbegin().
auto i1 = Container.begin();
// i1 is Container<T>::iterator
auto i2 = Container.cbegin();
// i2 is Container<T>::const_iterator
cend
Récupère un itérateur const (en lecture seule) à l’élément qui suit le dernier élément du conteneur spécifié.
template <class Container>
auto cend(const Container& cont)
-> decltype(cont.end());
Paramètres
cont
Un conteneur ou initializer_list.
Valeur de retour
Constante cont.end().
Notes
Cette fonction fonctionne avec tous les conteneurs de bibliothèque C++ Standard et avec initializer_list.
Vous pouvez utiliser cette fonction membre à la place de la fonction de modèle end() afin de garantir que la valeur de retour est const_iterator. En règle générale, il est utilisé avec le auto mot clé de déduction de type, comme illustré dans l’exemple suivant. Dans cet exemple, il est supposé que Container est un conteneur modifiable (autre que const) ou un initializer_list de tout type prenant en charge end() et cend().
auto i1 = Container.end();
// i1 is Container<T>::iterator
auto i2 = Container.cend();
// i2 is Container<T>::const_iterator
crbegin
Obtenez un itérateur en lecture seule inversée sur les éléments du conteneur, en commençant à la fin du conteneur.
template <class C> constexpr auto crbegin(const C& c) -> decltype(std::rbegin(c));
Paramètres
C
Type du conteneur.
c
Instance de conteneur.
Valeur retournée
Cet itérateur retourne les éléments du conteneur dans l’ordre inverse, en commençant à la fin du conteneur.
Exemple : crbegin
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
for (auto i = std::crbegin(v); i != std::crend(v); ++i)
{
std::cout << *i << ' '; // outputs 30 20 10
}
// v[1] = 100; // error because the iterator is const
}
30 20 10
crend
Obtenez la sentinelle à la fin d’une séquence inversée en lecture seule d’éléments.
template <class C> constexpr auto crend(const C& c) -> decltype(std::rend(c));
Paramètres
C
Type du conteneur.
c
Instance de conteneur.
Valeur retournée
La sentinelle suit le dernier élément dans une vue inversée du conteneur.
Exemple crend
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
auto vi = std::crend(v);
--vi; // get off the sentinel and onto the last element in the reversed range
std::cout << *vi; // outputs 10
// vi[0] = 300; // error because the iterator is const
}
10
data
Obtenez un pointeur vers le premier élément du conteneur.
1) template <class C> constexpr auto data(C& c) -> decltype(c.data());
2) template <class C> constexpr auto data(const C& c) -> decltype(c.data());
3) template <class T, size_t N> constexpr T* data(T (&array)[N]) noexcept;
4) template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
Paramètres
C
Type du conteneur.
c
Instance d’un conteneur.
E
Type d’élément de la liste d’initialiseurs.
il
Liste d’initialiseurs.
N
Nombre d’éléments dans le tableau.
T
Type des données dans le tableau.
Valeur retournée
1, 2) Pointeur, basé sur le type du conteneur, vers le premier élément. Par exemple, si le conteneur est un vecteur d’entiers, le type de la valeur de retour est un int *.
3) Pointeur vers le premier élément sous forme de tableau.
4) Pointeur vers le premier élément de la liste d’initialiseurs.
Exemple data
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
std::string src{ "a string" };
const char *charPtr = std::data(src);
int* intPtr = std::data(v);
std::cout << charPtr << ", " << *intPtr << '\n'; // a string, 10
}
a string, 10
distance
Détermine le nombre d'incréments entre les positions traitées par deux itérateurs.
template <class InputIterator>
typename iterator_traits<InputIterator>::difference_type distance(InputIterator first, InputIterator last);
Paramètres
first
Premier itérateur dont la distance à partir du deuxième doit être déterminée.
last
Deuxième itérateur dont la distance à partir du premier doit être déterminée.
Valeur de retour
Nombre de fois qui first doivent être incrémentés jusqu’à ce qu’il soit lastégal à .
Notes
La fonction de distance a une complexité constante lorsqu’elle InputIterator répond aux exigences d’un itérateur d’accès aléatoire ; sinon, elle a une complexité linéaire et est donc potentiellement coûteuse.
Exemple
// iterator_distance.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = -1; i < 9; ++i)
{
L.push_back(2 * i);
}
list <int>::iterator L_Iter, LPOS = L.begin();
cout << "The list L is: ( ";
for (L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
cout << "The iterator LPOS initially points to the first element: "
<< *LPOS << "." << endl;
advance(LPOS, 7);
cout << "LPOS is advanced 7 steps forward to point "
<< " to the eighth element: "
<< *LPOS << "." << endl;
list<int>::difference_type Ldiff;
Ldiff = distance(L.begin(), LPOS);
cout << "The distance from L.begin( ) to LPOS is: "
<< Ldiff << "." << endl;
}
The list L is: ( -2 0 2 4 6 8 10 12 14 16 ).
The iterator LPOS initially points to the first element: -2.
LPOS is advanced 7 steps forward to point to the eighth element: 12.
The distance from L.begin( ) to LPOS is: 7.
empty
template <class C> constexpr auto empty(const C& c) -> decltype(c.empty());
template <class T, size_t N> constexpr bool empty(const T (&array)[N]) noexcept;
template <class E> constexpr bool empty(initializer_list<E> il) noexcept;
Paramètres
C
Type du conteneur.
c
Instance d’un conteneur.
E
Type d’élément de la liste d’initialiseurs.
il
Liste d’initialiseurs.
N
Nombre d’éléments dans le tableau.
T
Type des données dans le tableau.
Valeur retournée
Retourne true si le conteneur n’a aucun élément ; sinon false.
Exemple
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10,20,30 };
std::vector<int> v2;
std::cout << std::boolalpha << std::empty(v); // outputs false
std::cout << std::boolalpha << ", " << std::empty(v2); // outputs true
}
false, true
end
Récupère un itérateur de l'élément qui suit le dernier élément dans le conteneur spécifié.
template <class Container>
auto end(Container& cont)
-> decltype(cont.end());
template <class Container>
auto end(const Container& cont)
-> decltype(cont.end());
template <class Ty, class Size>
Ty *end(Ty (& array)[Size]);
Paramètres
cont
Conteneur.
array
Tableau d'objets de type Ty.
Valeur de retour
Les deux premières fonctions de modèle retournent cont.end() (la première est non constante et la deuxième est constante).
La troisième fonction de modèle retourne array + Size.
Notes
Pour obtenir un exemple de code, consultez begin.
front_inserter
Crée un itérateur qui peut insérer des éléments à l'avant d'un conteneur spécifié.
template <class Container>
front_insert_iterator<Container> front_inserter(Container& Cont);
Paramètres
Cont
Objet conteneur à l’avant duquel un élément est inséré.
Valeur de retour
front_insert_iterator associé à l’objet conteneur Cont.
Notes
Vous pouvez aussi utiliser la fonction membre front_insert_iterator de la classe front_insert_iterator.
Dans la bibliothèque standard C++, l’argument doit faire référence à l’un des deux conteneurs de séquence ayant la fonction membre push_back : classe deque ou « classe list ».
Exemple
// iterator_front_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = -1; i < 9; ++i)
{
L.push_back(i);
}
cout << "The list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
// Using the template function to insert an element
front_insert_iterator<list <int>> Iter(L);
*Iter = 100;
// Alternatively, you may use the front_insert member function
front_inserter(L) = 200;
cout << "After the front insertions, the list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
}
The list L is:
( -1 0 1 2 3 4 5 6 7 8 ).
After the front insertions, the list L is:
( 200 100 -1 0 1 2 3 4 5 6 7 8 ).
inserter
Fonction de modèle d’assistance qui vous permet d’utiliser inserter(Cont, Where) au lieu de insert_iterator<Container>(Cont, Where).
template <class Container>
insert_iterator<Container>
inserter(
Container& Cont,
typename Container::iterator Where);
Paramètres
Cont
Conteneur auquel de nouveaux éléments doivent être ajoutés.
Where
Itérateur localisant le point d’insertion.
Notes
La fonction de modèle retourne insert_iterator<Container>(Cont, Where).
Exemple
// iterator_inserter.cpp
// compile with: /EHsc
#include <iterator>
#include <list>
#include <iostream>
int main()
{
using namespace std;
list<int> L;
for (int i = 2; i < 5; ++i)
{
L.push_back(10 * i);
}
cout << "The list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
// Using the template version to insert an element
insert_iterator<list<int>> Iter(L, L.begin());
*Iter = 1;
// Alternatively, using the member function to insert an element
inserter(L, L.end()) = 500;
cout << "After the insertions, the list L is:\n ( ";
for (auto L_Iter = L.begin(); L_Iter != L.end(); L_Iter++)
{
cout << *L_Iter << " ";
}
cout << ")." << endl;
}
The list L is:
( 20 30 40 ).
After the insertions, the list L is:
( 1 20 30 40 500 ).
make_checked_array_iterator
Crée un checked_array_iterator qui peut être utilisé par d’autres algorithmes.
Remarque
Cette fonction est une extension Microsoft de la bibliothèque standard C++. Le code implémenté à l’aide de cette fonction ne peut pas être utilisé dans les environnements de build C++ standard qui ne prennent pas en charge cette extension Microsoft.
template <class Iter>
checked_array_iterator<Iter>
make_checked_array_iterator(
Iter Ptr,
size_t Size,
size_t Index = 0);
Paramètres
Ptr
Pointeur vers le tableau de destination.
Size
Taille du tableau de destination.
Index
Index facultatif du tableau.
Valeur de retour
Instance de checked_array_iterator.
Notes
La fonction make_checked_array_iterator est définie dans l'espace de noms stdext.
Cette fonction accepte un pointeur brut (qui cause habituellement un problème de débordement de limites) et l’enveloppe dans une classe checked_array_iterator qui effectue une vérification. Cette classe étant marquée comme vérifiée, la bibliothèque standard C++ n’affiche pas d’avertissement. Pour plus d’informations et pour obtenir des exemples de code, consultez Itérateurs vérifiés.
Exemple
Dans l’exemple suivant, un vecteur est créé et rempli avec 10 éléments. Le contenu du vecteur est copié dans un tableau à l'aide de l'algorithme de copie, puis make_checked_array_iterator est utilisé pour spécifier la destination. Ceci est suivi d'une violation intentionnelle de la vérification des limites, afin de déclencher un échec d'assertion de débogage.
// make_checked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd
#include <algorithm>
#include <iterator> // stdext::make_checked_array_iterator
#include <memory> // std::make_unique
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <typename C> void print(const string& s, const C& c)
{
cout << s;
for (const auto& e : c)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
const size_t dest_size = 10;
// Old-school but not exception safe, favor make_unique<int[]>
// int* dest = new int[dest_size];
unique_ptr<int[]> updest = make_unique<int[]>(dest_size);
int* dest = updest.get(); // get a raw pointer for the demo
vector<int> v;
for (int i = 0; i < dest_size; ++i)
{
v.push_back(i);
}
print("vector v: ", v);
copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));
cout << "int array dest: ";
for (int i = 0; i < dest_size; ++i)
{
cout << dest[i] << " ";
}
cout << endl;
// Add another element to the vector to force an overrun.
v.push_back(10);
// ! The next line causes a debug assertion when it executes.
copy(v.begin(), v.end(), stdext::make_checked_array_iterator(dest, dest_size));
}
make_move_iterator
Crée un move iterator qui contient l’itérateur fourni en tant qu’itérateur stored.
template <class Iterator>
move_iterator<Iterator>
make_move_iterator(const Iterator& It);
Paramètres
It
Itérateur stocké dans le nouvel itérateur de déplacement.
Notes
La fonction de modèle retourne move_iterator <Iterator>(_It).
make_unchecked_array_iterator
Crée un unchecked_array_iterator qui peut être utilisé par d’autres algorithmes.
Remarque
Cette fonction est une extension Microsoft de la bibliothèque standard C++. Le code implémenté à l’aide de cette fonction ne peut pas être utilisé dans les environnements de build C++ standard qui ne prennent pas en charge cette extension Microsoft.
template <class Iter>
unchecked_array_iterator<Iter>
make_unchecked_array_iterator(Iter Ptr);
Paramètres
Ptr
Pointeur vers le tableau de destination.
Valeur de retour
Instance de unchecked_array_iterator.
Notes
La fonction make_unchecked_array_iterator est définie dans l'espace de noms stdext.
Cette fonction accepte un pointeur brut et l’enveloppe dans une classe qui n’effectue aucune vérification. Outre l’optimisation qui en résulte, cela fait taire les avertissements du compilateur, tels que C4996. Il s'agit donc d'une méthode ciblée permettant de gérer les avertissements des pointeurs non vérifiés, sans tous les faire taire ou faire l'effort d'une vérification. Pour plus d’informations et pour obtenir des exemples de code, consultez Itérateurs vérifiés.
Exemple
Dans l’exemple suivant, un vecteur est créé et rempli avec 10 éléments. Le contenu du vecteur est copié dans un tableau à l'aide de l'algorithme de copie, puis make_unchecked_array_iterator est utilisé pour spécifier la destination.
// make_unchecked_array_iterator.cpp
// compile with: /EHsc /W4 /MTd
#include <algorithm>
#include <iterator> // stdext::make_unchecked_array_iterator
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <typename C> void print(const string& s, const C& c)
{
cout << s;
for (const auto& e : c)
{
cout << e << " ";
}
cout << endl;
}
int main()
{
const size_t dest_size = 10;
int* dest = new int[dest_size];
vector<int> v;
for (int i = 0; i < dest_size; ++i)
{
v.push_back(i);
}
print("vector v: ", v);
// COMPILER WARNING SILENCED: stdext::unchecked_array_iterator is marked as checked in debug mode
// (it performs no checking, so an overrun will trigger undefined behavior)
copy(v.begin(), v.end(), stdext::make_unchecked_array_iterator(dest));
cout << "int array dest: ";
for (int i = 0; i < dest_size; ++i)
{
cout << dest[i] << " ";
}
cout << endl;
delete[] dest;
}
vector v: 0 1 2 3 4 5 6 7 8 9
int array dest: 0 1 2 3 4 5 6 7 8 9
next
Itère un nombre de fois donné et retourne la nouvelle position de l'itérateur.
template <class InputIterator>
InputIterator next(
InputIterator first,
typename iterator_traits<InputIterator>::difference_type off = 1);
Paramètres
first
Position actuelle.
off
Nombre d’itérations à effectuer.
Valeur de retour
Retourne la nouvelle position de l’itérateur après off itérations.
Notes
La fonction de modèle retourne next incrémenté off fois.
prev
Itère en sens inverse un nombre de fois donné et retourne la nouvelle position de l'itérateur.
template <class BidirectionalIterator>
BidirectionalIterator prev(
BidirectionalIterator first,
typename iterator_traits<BidirectionalIterator>::difference_type off = 1);
Paramètres
first
Position actuelle.
off
Nombre d’itérations à effectuer.
Notes
La fonction de modèle retourne next décrémenté off fois.
rbegin
Obtenez un itérateur, qui retourne les éléments du conteneur dans l’ordre inverse.
template <class C> constexpr auto rbegin(C& c) -> decltype(c.rbegin());
template <class C> constexpr auto rbegin(const C& c) -> decltype(c.rbegin());
Paramètres
C
Type du conteneur.
c
Instance de conteneur.
Valeur retournée
L’itérateur retourné présente les éléments du conteneur dans l’ordre inverse, en commençant à la fin de la plage inversée.
Exemple rbegin
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
for (auto e = std::rbegin(v); e != std::rend(v); ++e)
{
std::cout << *e << ' '; // outputs 30 20 10
}
}
30 20 10
rend
Obtenez la sentinelle à la fin d’une séquence inversée d’éléments.
template <class C> constexpr auto rend(C& c)-> decltype(c.rend());
template <class C> constexpr auto rend(const C& c) -> decltype(c.rend());
Paramètres
C
Type du conteneur.
c
Instance de conteneur.
Valeur retournée
Itérateur inverse vers la sentinelle à la fin du conteneur. La sentinelle suit le dernier élément de la vue inversée du conteneur :
Exemple rend
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{10, 20, 30};
auto vi = std::rend(v);
--vi; // get off the sentinel and onto the last element in the reversed range
std::cout << *vi; // outputs 10
}
10
size
template <class C> constexpr auto size(const C& c)
-> decltype(c.size());
template <class T, size_t N> constexpr size_t size(const T (&array)[N]) noexcept;
Paramètres
C
Type du conteneur.
c
Instance d’un conteneur.
N
Nombre d’éléments dans le tableau.
T
Type des données dans le tableau.
Valeur retournée
Nombre d’éléments dans le conteneur sous forme de valeur entière non signée.
Exemple size
#include <vector>
#include <iostream>
int main()
{
std::vector<int> v{ 10, 20, 30 };
size_t s = std::size(v);
std::cout << s; // outputs 3
}
3