CopyTo Method
Collapse the table of content
Expand the table of content

Queue::CopyTo Method (Array^, Int32)

 

Copies the Queue elements to an existing one-dimensional Array, starting at the specified array index.

Namespace:   System.Collections
Assembly:  mscorlib (in mscorlib.dll)

public:
virtual void CopyTo(
	Array^ array,
	int index
)

Parameters

array
Type: System::Array^

The one-dimensional Array that is the destination of the elements copied from Queue. The Array must have zero-based indexing.

index
Type: System::Int32

The zero-based index in array at which copying begins.

Exception Condition
ArgumentNullException

array is null.

ArgumentOutOfRangeException

index is less than zero.

ArgumentException

array is multidimensional.

-or-

The number of elements in the source Queue is greater than the available space from index to the end of the destination array.

ArrayTypeMismatchException

The type of the source Queue cannot be cast automatically to the type of the destination array.

The elements are copied to the Array in the same order in which the enumerator iterates through the Queue.

This method is an O(n) operation, where n is Count.

The following example shows how to copy a Queue into a one-dimensional array.

using namespace System;
using namespace System::Collections;
void PrintValues( Array^ myArr, char mySeparator );
int main()
{
   // Creates and initializes the source Queue.
   Queue^ mySourceQ = gcnew Queue;
   mySourceQ->Enqueue( "three" );
   mySourceQ->Enqueue( "napping" );
   mySourceQ->Enqueue( "cats" );
   mySourceQ->Enqueue( "in" );
   mySourceQ->Enqueue( "the" );
   mySourceQ->Enqueue( "barn" );

   // Creates and initializes the one-dimensional target Array.
   Array^ myTargetArray = Array::CreateInstance( String::typeid, 15 );
   myTargetArray->SetValue( "The", 0 );
   myTargetArray->SetValue( "quick", 1 );
   myTargetArray->SetValue( "brown", 2 );
   myTargetArray->SetValue( "fox", 3 );
   myTargetArray->SetValue( "jumped", 4 );
   myTargetArray->SetValue( "over", 5 );
   myTargetArray->SetValue( "the", 6 );
   myTargetArray->SetValue( "lazy", 7 );
   myTargetArray->SetValue( "dog", 8 );

   // Displays the values of the target Array.
   Console::WriteLine( "The target Array contains the following (before and after copying):" );
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Queue to the target Array, starting at index 6.
   mySourceQ->CopyTo( myTargetArray, 6 );

   // Displays the values of the target Array.
   PrintValues( myTargetArray, ' ' );

   // Copies the entire source Queue to a new standard array.
   array<Object^>^myStandardArray = mySourceQ->ToArray();

   // Displays the values of the new standard array.
   Console::WriteLine( "The new standard array contains the following:" );
   PrintValues( myStandardArray, ' ' );
}

void PrintValues( Array^ myArr, char mySeparator )
{
   IEnumerator^ myEnum = myArr->GetEnumerator();
   while ( myEnum->MoveNext() )
   {
      Object^ myObj = safe_cast<Object^>(myEnum->Current);
      Console::Write( "{0}{1}", mySeparator, myObj );
   }

   Console::WriteLine();
}

/* 
 This code produces the following output.

 The target Array contains the following (before and after copying):
  The quick brown fox jumped over the lazy dog
  The quick brown fox jumped over three napping cats in the barn
 The new standard array contains the following:
  three napping cats in the barn

 */

Universal Windows Platform
Available since 10
.NET Framework
Available since 1.1
Return to top
Show:
© 2016 Microsoft