Queue.CopyTo(Array, Int32) Metoda

Definice

Obor názvů:

System.Collections

Sestavení:

System.Collections.NonGeneric.dll

Zdroj:

Queue.cs

Zkopíruje Queue prvky do existujícího jednorozměrného Arrayobjektu , počínaje zadaným indexem pole.

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

public virtual void CopyTo (Array array, int index);

abstract member CopyTo : Array * int -> unit
override this.CopyTo : Array * int -> unit

Public Overridable Sub CopyTo (array As Array, index As Integer)

Parametry

array

Array

Jednorozměrný Array , který je cílem elementů zkopírovaných z Queue. Musí Array mít indexování založené na nule.

index

Int32

Index založený na nule v poli array, ve kterém kopírování začíná.

Implementuje

CopyTo(Array, Int32)

Výjimky

ArgumentNullException

array je null.

ArgumentOutOfRangeException

Hodnota index je menší než nula.

ArgumentException

Pole array je multidimenzionální.

-nebo-

Počet prvků ve zdroji Queue je větší než dostupné místo od index konce cíle array.

ArrayTypeMismatchException

Typ zdroje Queue nelze automaticky přetypovat na typ cílového array.

Příklady

Následující příklad ukazuje, jak zkopírovat Queue do jednorozměrného pole.

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( "jumps", 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 jumps over the lazy dog
  The quick brown fox jumps over three napping cats in the barn
 The new standard array contains the following:
  three napping cats in the barn

 */

using System;
using System.Collections;
public class SamplesQueue  {

   public static void Main()  {

      // Creates and initializes the source Queue.
      Queue mySourceQ = new 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( typeof(string), 15 );
      myTargetArray.SetValue( "The", 0 );
      myTargetArray.SetValue( "quick", 1 );
      myTargetArray.SetValue( "brown", 2 );
      myTargetArray.SetValue( "fox", 3 );
      myTargetArray.SetValue( "jumps", 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.
      Object[] myStandardArray = mySourceQ.ToArray();

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

   public static void PrintValues( Array myArr, char mySeparator )  {
      foreach ( Object myObj in myArr )  {
         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 jumps over the lazy dog
 The quick brown fox jumps over three napping cats in the barn
The new standard array contains the following:
 three napping cats in the barn

*/

Imports System.Collections

Public Class SamplesQueue    

    Public Shared Sub Main()

        ' Creates and initializes the source Queue.
        Dim mySourceQ As New 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.
        Dim myTargetArray As Array = Array.CreateInstance(GetType(String), 15)
        myTargetArray.SetValue("The", 0)
        myTargetArray.SetValue("quick", 1)
        myTargetArray.SetValue("brown", 2)
        myTargetArray.SetValue("fox", 3)
        myTargetArray.SetValue("jumps", 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, " "c)

        ' 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, " "c)

        ' Copies the entire source Queue to a new standard array.
        Dim myStandardArray As Object() = mySourceQ.ToArray()

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

    End Sub

    Public Shared Sub PrintValues(myArr As Array, mySeparator As Char)
        Dim myObj As [Object]
        For Each myObj In  myArr
            Console.Write("{0}{1}", mySeparator, myObj)
        Next myObj
        Console.WriteLine()
    End Sub

End Class


' This code produces the following output.
' 
' The target Array contains the following (before and after copying):
'  The quick brown fox jumps over the lazy dog
'  The quick brown fox jumps over three napping cats in the barn
' The new standard array contains the following:
'  three napping cats in the barn

Poznámky

Prvky se zkopírují do objektu Array ve stejném pořadí, ve kterém iterátor výčtu prochází .Queue

Tato metoda je O(n) operace, kde n je Count.