<cliext/adapter>
(STL/CLR)
Nagłówek <cliext/adapter>
STL/CLR określa dwa szablony klas (collection_adapter
i range_adapter
) oraz szablon make_collection
funkcji .
Składnia
#include <cliext/adapter>
Wymagania
Header:<cliext/adapter>
Przestrzeń nazw: cliext
Deklaracje
Klasa | opis |
---|---|
collection_adapter |
Opakowuje kolekcję biblioteki klas bazowych (BCL) jako zakres. |
range_adapter |
Opakowuje zakres jako kolekcję BCL. |
Function | opis |
---|---|
make_collection |
Tworzy adapter zakresu przy użyciu pary iteratora. |
Elementy członkowskie
collection_adapter
Opakowuje kolekcję platformy .NET do użycia jako kontener STL/CLR. A collection_adapter
to klasa szablonu, która opisuje prosty obiekt kontenera STL/CLR. Opakowuje interfejs biblioteki klas bazowych (BCL) i zwraca parę iteratora używaną do manipulowania kontrolowaną sekwencją.
Składnia
template<typename Coll>
ref class collection_adapter;
template<>
ref class collection_adapter<
System::Collections::ICollection>;
template<>
ref class collection_adapter<
System::Collections::IEnumerable>;
template<>
ref class collection_adapter<
System::Collections::IList>;
template<>
ref class collection_adapter<
System::Collections::IDictionary>;
template<typename Value>
ref class collection_adapter<
System::Collections::Generic::ICollection<Value>>;
template<typename Value>
ref class collection_adapter<
System::Collections::Generic::IEnumerable<Value>>;
template<typename Value>
ref class collection_adapter<
System::Collections::Generic::IList<Value>>;
template<typename Key,
typename Value>
ref class collection_adapter<
System::Collections::Generic::IDictionary<Key, Value>>;
Parametry
Coll
Typ opakowanej kolekcji.
Specjalizacje
Specjalizacja | opis |
---|---|
IEnumerable |
Sekwencje przez elementy. |
ICollection |
Utrzymuje grupę elementów. |
IList |
Utrzymuje uporządkowaną grupę elementów. |
IDictionary |
Obsługa zestawu par {key, value}. |
IEnumerable<Value> |
Sekwencje po typowanych elementach. |
ICollection<Value> |
Utrzymuje grupę typowanych elementów. |
IList<Value> |
Utrzymuje uporządkowaną grupę typowanych elementów. |
IDictionary<Value> |
Utrzymuje zestaw typowanych par {key, value}. |
Elementy członkowskie
Definicja typu | opis |
---|---|
collection_adapter::difference_type |
Typ odległości ze znakiem między dwoma elementami. |
collection_adapter::iterator |
Typ iteratora dla kontrolowanej sekwencji. |
collection_adapter::key_type |
Typ klucza słownika. |
collection_adapter::mapped_type |
Typ wartości słownika. |
collection_adapter::reference |
Typ odwołania do elementu. |
collection_adapter::size_type |
Typ odległości ze znakiem między dwoma elementami. |
collection_adapter::value_type |
Typ elementu. |
Funkcja składowa | opis |
---|---|
collection_adapter::base |
Wyznacza opakowany interfejs BCL. |
collection_adapter::begin |
Określa początek kontrolowanej sekwencji. |
collection_adapter::collection_adapter |
Tworzy obiekt adaptera. |
collection_adapter::end |
Określa koniec kontrolowanej sekwencji. |
collection_adapter::size |
Liczy liczbę elementów. |
collection_adapter::swap |
Zamienia zawartości dwóch kontenerów. |
Operator | opis |
---|---|
collection_adapter::operator= |
Zastępuje przechowywany uchwyt listy BCL. |
Uwagi
Ta klasa szablonu służy do manipulowania kontenerem BCL jako kontenerem STL/CLR. Przechowuje collection_adapter
uchwyt do interfejsu BCL, który z kolei steruje sekwencją elementów. Obiekt collection_adapter
X
zwraca parę iteratorów wejściowych X.begin()
i X.end()
służy do odwiedzania elementów w kolejności. Niektóre specjalizacje umożliwiają również pisanie X.size()
w celu określenia długości kontrolowanej sekwencji.
collection_adapter::base
Wyznacza opakowany interfejs BCL.
Składnia
Coll^ base();
Uwagi
Funkcja składowa zwraca przechowywany uchwyt interfejsu BCL.
Przykład
// cliext_collection_adapter_base.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d6x(6, L'x');
Mycoll c1(%d6x);
// display initial contents "x x x x x x "
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("base() same = {0}", c1.base() == %c1);
return (0);
}
x x x x x x
base() same = True
collection_adapter::begin
Określa początek kontrolowanej sekwencji.
Składnia
iterator begin();
Uwagi
Funkcja składowa zwraca iterator wejściowy, który wyznacza pierwszy element kontrolowanej sekwencji lub tuż poza końcem pustej sekwencji.
Przykład
// cliext_collection_adapter_begin.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// inspect first two items
Mycoll::iterator it = c1.begin();
System::Console::WriteLine("*begin() = {0}", *it);
System::Console::WriteLine("*++begin() = {0}", *++it);
return (0);
}
a b c
*begin() = a
*++begin() = b
collection_adapter::collection_adapter
Tworzy obiekt adaptera.
Składnia
collection_adapter();
collection_adapter(collection_adapter<Coll>% right);
collection_adapter(collection_adapter<Coll>^ right);
collection_adapter(Coll^ collection);
Parametry
collection
Uchwyt listy BCL do zawijania.
right
Obiekt do skopiowania.
Uwagi
Konstruktor:
collection_adapter();
Inicjuje przechowywany uchwyt za pomocą polecenia nullptr
.
Konstruktor:
collection_adapter(collection_adapter<Coll>% right);
Inicjuje przechowywany uchwyt za pomocą polecenia right.base()
.
Konstruktor:
collection_adapter(collection_adapter<Coll>^ right);
Inicjuje przechowywany uchwyt za pomocą polecenia right->base()
.
Konstruktor:
collection_adapter(Coll^ collection);
Inicjuje przechowywany uchwyt za pomocą polecenia collection
.
Przykład
// cliext_collection_adapter_construct.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d6x(6, L'x');
// construct an empty container
Mycoll c1;
System::Console::WriteLine("base() null = {0}", c1.base() == nullptr);
// construct with a handle
Mycoll c2(%d6x);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another container
Mycoll c3(c2);
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying a container handle
Mycoll c4(%c3);
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
base() null = True
x x x x x x
x x x x x x
x x x x x x
collection_adapter::difference_type
Typy podpisanej odległości między dwoma elementami.
Składnia
typedef int difference_type;
Uwagi
Typ opisuje liczbę podpisanych elementów.
Przykład
// cliext_collection_adapter_difference_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// compute positive difference
Mycoll::difference_type diff = 0;
Mycoll::iterator it = c1.begin();
for (; it != c1.end(); ++it)
++diff;
System::Console::WriteLine("end()-begin() = {0}", diff);
return (0);
}
a b c
end()-begin() = 3
collection_adapter::end
Określa koniec kontrolowanej sekwencji.
Składnia
iterator end();
Uwagi
Funkcja składowa zwraca iterator wejściowy, który wskazuje tuż poza koniec kontrolowanej sekwencji.
Przykład
// cliext_collection_adapter_end.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
Mycoll::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
collection_adapter::iterator
Typ iteratora dla kontrolowanej sekwencji.
Składnia
typedef T1 iterator;
Uwagi
Typ opisuje obiekt nieokreślonego typu T1
, który może służyć jako iterator wejściowy dla kontrolowanej sekwencji.
Przykład
// cliext_collection_adapter_iterator.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
Mycoll::iterator it = c1.begin();
for (; it != c1.end(); ++it)
System::Console::Write("{0} ", *it);
System::Console::WriteLine();
return (0);
}
a b c
collection_adapter::key_type
Typ klucza słownika.
Składnia
typedef Key key_type;
Uwagi
Typ jest synonimem parametru Key
szablonu , w specjalizacji IDictionary
IDictionary<Value>
lub ; w przeciwnym razie nie jest zdefiniowany.
Przykład
// cliext_collection_adapter_key_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/map>
typedef cliext::map<wchar_t, int> Mymap;
typedef cliext::collection_adapter<
System::Collections::Generic::IDictionary<wchar_t, int>> Mycoll;
typedef System::Collections::Generic::KeyValuePair<wchar_t,int> Mypair;
int main()
{
Mymap d1;
d1.insert(Mymap::make_value(L'a', 1));
d1.insert(Mymap::make_value(L'b', 2));
d1.insert(Mymap::make_value(L'c', 3));
Mycoll c1(%d1);
// display contents "[a 1] [b 2] [c 3] "
for each (Mypair elem in c1)
{
Mycoll::key_type key = elem.Key;
Mycoll::mapped_type value = elem.Value;
System::Console::Write("[{0} {1}] ", key, value);
}
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
collection_adapter::mapped_type
Typ wartości słownika.
Składnia
typedef Value mapped_type;
Uwagi
Typ jest synonimem parametru Value
szablonu , w specjalizacji IDictionary
IDictionary<Value>
lub ; w przeciwnym razie nie jest zdefiniowany.
Przykład
// cliext_collection_adapter_mapped_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/map>
typedef cliext::map<wchar_t, int> Mymap;
typedef cliext::collection_adapter<
System::Collections::Generic::IDictionary<wchar_t, int>> Mycoll;
typedef System::Collections::Generic::KeyValuePair<wchar_t,int> Mypair;
int main()
{
Mymap d1;
d1.insert(Mymap::make_value(L'a', 1));
d1.insert(Mymap::make_value(L'b', 2));
d1.insert(Mymap::make_value(L'c', 3));
Mycoll c1(%d1);
// display contents "[a 1] [b 2] [c 3] "
for each (Mypair elem in c1)
{
Mycoll::key_type key = elem.Key;
Mycoll::mapped_type value = elem.Value;
System::Console::Write("[{0} {1}] ", key, value);
}
System::Console::WriteLine();
return (0);
}
[a 1] [b 2] [c 3]
collection_adapter::operator=
Zastępuje przechowywany uchwyt listy BCL.
Składnia
collection_adapter<Coll>% operator=(collection_adapter<Coll>% right);
Parametry
right
Adapter do skopiowania.
Uwagi
Operator elementu członkowskiego kopiuje right
do obiektu, a następnie zwraca wartość *this
. Służy do zastępowania przechowywanego dojścia BCL kopią przechowywanego uchwytu listy BCL w programie right
.
Przykład
// cliext_collection_adapter_operator_as.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
Mycoll c2;
c2 = c1;
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
collection_adapter::reference
Typ odwołania do elementu.
Składnia
typedef value_type% reference;
Uwagi
Typ opisuje odwołanie do elementu.
Przykład
// cliext_collection_adapter_reference.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents "a b c "
Mycoll::iterator it = c1.begin();
for (; it != c1.end(); ++it)
{ // get a reference to an element
Mycoll::reference ref = *it;
System::Console::Write("{0} ", ref);
}
System::Console::WriteLine();
return (0);
}
a b c
collection_adapter::size
Liczy liczbę elementów.
Składnia
size_type size();
Uwagi
Funkcja składowa zwraca długość kontrolowanej sekwencji. Nie jest ona zdefiniowana w specjalizacji dla IEnumerable
programu lub IEnumerable<Value>
.
Przykład
// cliext_collection_adapter_size.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d6x(6, L'x');
Mycoll c1(%d6x);
// display initial contents "x x x x x x "
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Console::WriteLine("size() = {0}", c1.size());
return (0);
}
x x x x x x
size() = 6
collection_adapter::size_type
Typ odległości ze znakiem między dwoma elementami.
Składnia
typedef int size_type;
Uwagi
Typ opisuje nieujemną liczbę elementów.
Przykład
// cliext_collection_adapter_size_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d6x(6, L'x');
Mycoll c1(%d6x);
// display initial contents "x x x x x x"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
Mycoll::size_type size = c1.size();
System::Console::WriteLine("size() = {0}", size);
return (0);
}
x x x x x x
size() = 6
collection_adapter::swap
Zamienia zawartości dwóch kontenerów.
Składnia
void swap(collection_adapter<Coll>% right);
Parametry
right
Kontener do zamiany zawartości na.
Uwagi
Funkcja składowa zamienia przechowywane dojścia BCL między *this
i right
.
Przykład
// cliext_collection_adapter_swap.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display initial contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct another container with repetition of values
cliext::deque<wchar_t> d2(5, L'x');
Mycoll c2(%d2);
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// swap and redisplay
c1.swap(c2);
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
x x x x x
x x x x x
a b c
collection_adapter::value_type
Typ elementu.
Składnia
typedef Value value_type;
Uwagi
Typ jest synonimem parametru Value
szablonu , jeśli występuje w specjalizacji; w przeciwnym razie jest to synonim .System::Object^
Przykład
// cliext_collection_adapter_value_type.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::collection_adapter<
System::Collections::ICollection> Mycoll;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Mycoll c1(%d1);
// display contents "a b c" using value_type
for (Mycoll::iterator it = c1.begin();
it != c1.end(); ++it)
{ // store element in value_type object
Mycoll::value_type val = *it;
System::Console::Write("{0} ", val);
}
System::Console::WriteLine();
return (0);
}
a b c
make_collection (STL/CLR)
Utwórz element range_adapter
z pary iteratora.
Składnia
template<typename Iter>
range_adapter<Iter> make_collection(Iter first, Iter last);
Parametry
Iter
Typ opakowanych iteratorów.
first
Pierwszy iterator do opakowania.
last
Drugi iterator do opakowania.
Uwagi
Szablon funkcji zwraca wartość gcnew range_adapter<Iter>(first, last)
. Służy do konstruowania range_adapter<Iter>
obiektu z pary iteratorów.
Przykład
// cliext_make_collection.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
// display contents " a b c"
for each (wchar_t elem in d1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
System::Collections::ICollection^ p1 =
cliext::make_collection(d1.begin(), d1.end());
System::Console::WriteLine("Count = {0}", p1->Count);
System::Console::WriteLine("IsSynchronized = {0}",
p1->IsSynchronized);
System::Console::WriteLine("SyncRoot not nullptr = {0}",
p1->SyncRoot != nullptr);
// copy the sequence
cli::array<System::Object^>^ a1 = gcnew cli::array<System::Object^>(5);
a1[0] = L'|';
p1->CopyTo(a1, 1);
a1[4] = L'|';
for each (wchar_t elem in a1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
Count = 3
IsSynchronized = False
SyncRoot not nullptr = True
| a b c |
range_adapter (STL/CLR)
Klasa szablonu, która opakowuje parę iteratorów używanych do implementowania kilku interfejsów biblioteki klas bazowych (BCL). Za pomocą range_adapter można manipulować zakresem STL/CLR tak, jakby była to kolekcja BCL.
Składnia
template<typename Iter>
ref class range_adapter
: public
System::Collections::IEnumerable,
System::Collections::ICollection,
System::Collections::Generic::IEnumerable<Value>,
System::Collections::Generic::ICollection<Value>
{ ..... };
Parametry
Iter
Typ skojarzony z opakowanymi iteratorami.
Elementy członkowskie
Funkcja składowa | opis |
---|---|
range_adapter::range_adapter |
Tworzy obiekt adaptera. |
Operator | opis |
---|---|
range_adapter::operator= |
Zastępuje przechowywaną parę iteratora. |
Interfejsy
Interfejs | opis |
---|---|
IEnumerable | Iteruje przez elementy w kolekcji. |
ICollection | Utrzymuje grupę elementów. |
IEnumerable<T> | Iteruje po wpisanych elementach w kolekcji. |
ICollection<T> | Utrzymuje grupę typowanych elementów. |
Uwagi
Range_adapter przechowuje parę iteratorów, co z kolei rozdziela sekwencję elementów. Obiekt implementuje cztery interfejsy BCL, które pozwalają iterować przez elementy w kolejności. Ta klasa szablonu służy do manipulowania zakresami STL/CLR, podobnie jak kontenery BCL.
range_adapter::operator=
Zastępuje przechowywaną parę iteratora.
Składnia
range_adapter<Iter>% operator=(range_adapter<Iter>% right);
Parametry
right
Adapter do skopiowania.
Uwagi
Operator elementu członkowskiego kopiuje right
do obiektu, a następnie zwraca wartość *this
. Służy do zastępowania przechowywanej pary iteratora kopią przechowywanej pary iteratora w pliku right
.
Przykład
// cliext_range_adapter_operator_as.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
Myrange c1(d1.begin(), d1.end());
// display contents " a b c"
for each (wchar_t elem in c1)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// assign to a new container
Myrange c2;
c2 = c1;
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
range_adapter::range_adapter
Tworzy obiekt adaptera.
Składnia
range_adapter();
range_adapter(range_adapter<Iter>% right);
range_adapter(range_adapter<Iter>^ right);
range_adapter(Iter first, Iter last);
Parametry
first
Pierwszy iterator do opakowania.
last
Drugi iterator do opakowania.
right
Obiekt do skopiowania.
Uwagi
Konstruktor:
range_adapter();
Inicjuje przechowywaną parę iteratorów z domyślnymi skonstruowanymi iteratorami.
Konstruktor:
range_adapter(range_adapter<Iter>% right);
Inicjuje przechowywaną parę iteratora, kopiując parę przechowywaną w pliku right
.
Konstruktor:
range_adapter(range_adapter<Iter>^ right);
Inicjuje przechowywaną parę iteratora, kopiując parę przechowywaną w pliku *right
.
Konstruktor:
range_adapter(Iter^ first, last);
Inicjuje przechowywaną parę iteratora z elementami first
i last
.
Przykład
// cliext_range_adapter_construct.cpp
// compile with: /clr
#include <cliext/adapter>
#include <cliext/deque>
typedef cliext::deque<wchar_t> Mycont;
typedef cliext::range_adapter<Mycont::iterator> Myrange;
int main()
{
cliext::deque<wchar_t> d1;
d1.push_back(L'a');
d1.push_back(L'b');
d1.push_back(L'c');
// construct an empty adapter
Myrange c1;
// construct with an iterator pair
Myrange c2(d1.begin(), d1.end());
for each (wchar_t elem in c2)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying another adapter
Myrange c3(c2);
for each (wchar_t elem in c3)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
// construct by copying an adapter handle
Myrange c4(%c3);
for each (wchar_t elem in c4)
System::Console::Write("{0} ", elem);
System::Console::WriteLine();
return (0);
}
a b c
a b c
a b c
Opinia
https://aka.ms/ContentUserFeedback.
Dostępne już wkrótce: W 2024 r. będziemy stopniowo wycofywać zgłoszenia z serwisu GitHub jako mechanizm przesyłania opinii na temat zawartości i zastępować go nowym systemem opinii. Aby uzyskać więcej informacji, sprawdź:Prześlij i wyświetl opinię dla