valarray sınıfı

Sınıf şablonu valarray<Type> , dizi olarak depolanan, yüksek hızlı matematik işlemleri için tasarlanmış ve hesaplama performansı için iyileştirilmiş türdeki öğelerin Type dizisini denetleen bir nesneyi açıklar.

Açıklamalar

sınıfı, sıralı bir değer kümesinin matematiksel kavramının bir gösterimidir. Öğeleri sıfırdan sıralı olarak numaralandırılır. sınıfı, gibi vectorbirinci sınıf dizi kapsayıcılarının desteklediği özelliklerin bazılarını desteklediğinden ancak tümünü desteklemediğinden, kapsayıcıya yakın olarak tanımlanır. Sınıf şablonundan vector iki önemli şekilde farklıdır:

• Aynı türde ve uzunluktaki nesnelerin ilgili öğeleri valarray<Type> arasında birçok aritmetik işlem tanımlar. Örneğin varr_x* = cos(varr_y) + sin(varr_z), .

• nesnesini aşırı yükleyerek operator[]alt simge valarray<Type> oluşturmanın çeşitli ilginç yollarını tanımlar.

sınıfının Typenesnesi:

• Genel bir varsayılan oluşturucuya, yıkıcıya, kopya oluşturucuya ve geleneksel davranışa sahip atama işlecine sahiptir.

• Gerektiğinde, kayan nokta türleri için tanımlanan aritmetik işleçleri ve matematik işlevlerini geleneksel davranışla tanımlar.

Özellikle, kopya yapımı ile varsayılan yapı arasında küçük farklar olmayabilir ve bunu atama takip edebilir. Sınıfın Type nesneleri üzerindeki işlemlerin hiçbiri özel durumlar oluşturamayabilir.

Üyeler

Oluşturucular

Veri Akışı Adı	Açıklama
valarray	Belirli bir valarray boyutta veya belirli bir değerin öğeleriyle ya da başka bir veya başka valarray bir alt kümesinin valarraykopyası olarak oluşturur.

Tür tanımları

Veri Akışı Adı	Açıklama
value_type	içinde depolanan öğenin türünü temsil eden bir valarraytür.

İşlevler

Veri Akışı Adı	Açıklama
apply	Bir öğesinin her öğesine belirtilen bir valarrayişlevi uygular.
cshift	Döngüsel olarak içindeki valarray tüm öğeleri belirtilen sayıda konumla değiştirir.
free	tarafından kullanılan belleği serbest bırakır valarray.
max	içindeki valarrayen büyük öğeyi bulur.
min	içindeki valarrayen küçük öğeyi bulur.
resize	Öğeleri gerektiği gibi ekleyerek veya kaldırarak, bir valarray içindeki öğe sayısını belirtilen bir sayıya değiştirir.
shift	içindeki tüm öğeleri valarray belirtilen sayıda konumla değiştirir.
size	içindeki valarrayöğe sayısını bulur.
sum	Sıfır olmayan uzunluktaki valarray tüm öğelerin toplamını belirler.
swap

İşleçler

Veri Akışı Adı	Açıklama
operator!	içindeki her öğenin mantıksal NOT (!) değerlerini alan birli valarrayişleç.
operator%=	Bir dizi öğesinin öğelerini belirtilen valarray veya öğe türündeki bir değere bölmenin geri kalanını alır.
operator&=	Bir dizideki öğelerin bit düzeyinde AND (&) değerini, belirtilen valarray bir öğedeki karşılık gelen öğelerle veya öğe türündeki bir değerle alır.
operator>>=	bir valarray işlenenin her öğesi için bitleri belirtilen sayıda konumla veya bir saniyeyle valarraybelirtilen öğeye göre bir öğeye göre sağa kaydırıyor.
operator<<=	Bir işlenenin her öğesi valarray için bitleri belirtilen sayıda konum veya bir saniye valarrayile belirtilen öğeye göre bir miktar sola kaydırıyor.
operator*=	Belirtilen valarray veya öğe türündeki bir değerin öğelerini bir işlenenle valarrayçarpar.
operator+	içindeki her öğeye artı uygulayan birli valarrayişleç. Normal aritmetik türlerde bu işlecin hiçbir etkisi yoktur.
operator+=	belirtilen valarray veya öğe türündeki bir değerin öğelerini işlenene valarrayekler.
operator-	içindeki her öğeye aritmetik bir olumsuzlama uygulayan bir valarraytekli işleç.
operator-=	Belirtilen valarray veya öğe türündeki bir değerin öğelerini bir işlenenden valarrayçıkarır.
operator/=	İşlenen valarray öğe temelli bir öğeyi, belirtilen valarray veya öğe türündeki bir değerin öğelerine böler.
operator=	Değerleri doğrudan veya başka valarray bir valarray öğesinin parçası olarak ya da , gslice_array, mask_arrayveya indirect_arraytarafından belirtilen bir slice_arrayöğesine öğe atar.
operator[]	Belirtilen dizinde veya belirtilen alt kümede bir öğeye veya değerine başvuru döndürür.
operator^=	Belirtilen valarray veya öğe türünün değerine sahip bit valarray düzeyinde özel veya (^) değerini alır.
operator|=	Bir dizideki öğelerin bit düzeyinde OR (|) değerini, belirtilen valarray bir içindeki karşılık gelen öğelerle veya öğe türündeki bir değerle alır.
operator~	içindeki her öğenin bit düzeyinde tamamlayıcı (~) değerlerini alan birli valarrayişleç.

apply

Bir öğesinin her öğesine belirtilen bir valarrayişlevi uygular.

valarray<Type> apply(Type function_object(Type)) const;

valarray<Type> apply(Type function_object(const Type&)) const;

Parametreler

function_object(Type)
işleneninin her öğesine valarrayuygulanacak işlev nesnesi.

function_object(const Type&)
İşlenen valarrayöğesinin her öğesine uygulanacak öğelerin işlev nesnesiconst.

Dönüş değeri

valarray öğeleri function_object işlenenin valarrayöğelerine öğeye göre uygulanmış olan.

Açıklamalar

üye işlevi, her elem biri öğesinin sonucu function_object((*this)[elem])olan , uzunluğunda sizebir nesnesi valarray<Type>döndürür.

Örnek

// valarray_apply.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

using namespace std;

int __cdecl MyApplyFunc( int n )
{
   return n*2;
}

int main( int argc, char* argv[] )
{
   valarray<int> vaR(10), vaApplied(10);
   int i;

   for ( i = 0; i < 10; i += 3 )
      vaR[i] = i;

   for ( i = 1; i < 10; i += 3 )
      vaR[i] = 0;

   for ( i = 2; i < 10; i += 3 )
      vaR[i] = -i;

   cout << "The initial Right valarray is: (";
   for   ( i=0; i < 10; ++i )
      cout << " " << vaR[i];
   cout << " )" << endl;

   vaApplied = vaR.apply( MyApplyFunc );

   cout << "The element-by-element result of "
       << "applying MyApplyFunc to vaR is the\nvalarray: ( ";
   for ( i = 0; i < 10; ++i )
      cout << " " << vaApplied[i];
   cout << " )" << endl;
}

The initial Right valarray is: ( 0 0 -2 3 0 -5 6 0 -8 9 )
The element-by-element result of applying MyApplyFunc to vaR is the
valarray: (  0 0 -4 6 0 -10 12 0 -16 18 )

cshift

Döngüsel olarak içindeki valarray tüm öğeleri belirtilen sayıda konumla değiştirir.

valarray<Type> cshift(int count) const;

Parametreler

count
Öğelerin ileri kaydırılacağı yer sayısı.

Dönüş değeri

Tüm öğelerin önünde döngüsel olarak veya işlenendeki valarraykonumlarıyla valarraykarşılaştırıldığında sola doğru hareket ettirildiği count yeni valarray bir .

Açıklamalar

Pozitif değeri count , öğeleri döngüsel olarak sola count doğru kaydırır.

Negatif değeri count , öğeleri döngüsel olarak doğru count yerlere kaydırır.

Örnek

// valarray_cshift.cpp
// compile with: /EHsc

#include <valarray>
#include <iostream>

int main()
{
    using namespace std;
    int i;

    valarray<int> va1(10), va2(10);
    for (i = 0; i < 10; i+=1)
        va1[i] = i;
    for (i = 0; i < 10; i+=1)
        va2[i] = 10 - i;

    cout << "The operand valarray va1 is: (";
    for (i = 0; i < 10; i++)
        cout << " " << va1[i];
    cout << ")" << endl;

    // A positive parameter shifts elements right
    va1 = va1.cshift(4);
    cout << "The cyclically shifted valarray va1 is:\nva1.cshift (4) = (";
    for (i = 0; i < 10; i++)
        cout << " " << va1[i];
    cout << ")" << endl;

    cout << "The operand valarray va2 is: (";
    for (i = 0; i < 10; i++)
        cout << " " << va2[i];
    cout << ")" << endl;

    // A negative parameter shifts elements left
    va2 = va2.cshift(-4);
    cout << "The cyclically shifted valarray va2 is:\nva2.shift (-4) = (";
    for (i = 0; i < 10; i++)
        cout << " " << va2[i];
    cout << ")" << endl;
}

The operand valarray va1 is: ( 0 1 2 3 4 5 6 7 8 9)
The cyclically shifted valarray va1 is:
va1.cshift (4) = ( 4 5 6 7 8 9 0 1 2 3)
The operand valarray va2 is: ( 10 9 8 7 6 5 4 3 2 1)
The cyclically shifted valarray va2 is:
va2.shift (-4) = ( 4 3 2 1 10 9 8 7 6 5)

free

tarafından kullanılan belleği serbest bırakır valarray.

void free();

Açıklamalar

Bu standart olmayan işlev, boş valarraybir atamakla eşdeğerdir. Örneğin:

valarray<T> v;
v = valarray<T>();

// equivalent to v.free()

max

içindeki valarrayen büyük öğeyi bulur.

Type max() const;

Dönüş değeri

İşlenen valarrayiçindeki öğelerin en büyük değeri.

Açıklamalar

üye işlevi, öğesi Typeiçin işleçlerin sağlanması gereken sınıfı Typeöğelerinin çiftleri arasında işleç< veya işleç> uygulayarak değerleri karşılaştırır.

Örnek

// valarray_max.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i, MaxValue;

   valarray<int> vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  2*i - 1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  10 - i;

   cout << "The operand valarray is: ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   MaxValue = vaR.max (  );
   cout << "The largest element in the valarray is: "
        << MaxValue  << "." << endl;
}

The operand valarray is: ( 0 1 8 3 7 5 6 13 2 9 ).
The largest element in the valarray is: 13.

min

içindeki valarrayen küçük öğeyi bulur.

Type min() const;

Dönüş değeri

İşlenen valarrayiçindeki öğelerin en düşük değeri.

Açıklamalar

üye işlevi, öğesi Typeiçin işleçlerin sağlanması gereken sınıfı Typeöğelerinin çiftleri arasında işleç< veya işleç> uygulayarak değerleri karşılaştırır.

Örnek

// valarray_min.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i, MinValue;

   valarray<int> vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  2*i;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  5 - i;

   cout << "The operand valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   MinValue = vaR.min ( );
   cout << "The smallest element in the valarray is: "
        << MinValue  << "." << endl;
}
/* Output:
The operand valarray is: ( 0 2 3 -3 8 0 -6 14 -3 -9 ).
The smallest element in the valarray is: -9.
*/

operator!

içindeki her öğenin mantıksal NOT (!) değerlerini alan birli valarrayişleç.

valarray<bool> operator!() const;

Dönüş değeri

işleneninin valarray öğe değerlerinin mantıksal olumsuzlaması olan Boole değerlerinin valarraydeğeri.

Açıklamalar

tarafından !belirtilen DEĞİl mantıksal işlemi, tüm sıfır değerlerini içine ve sıfır olmayan tüm değerleri true içine dönüştürdüğünden öğeleri mantıksal olarak yok eder false. Boole değerlerinin döndürülen valarray değeri işlenenle valarrayaynı boyuttadır.

Örnek

// valarray_op_lognot.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 );
   valarray<bool> vaNOT ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;

   cout << "The initial valarray is:  ( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   vaNOT = !vaL;
   cout << "The element-by-element result of "
        << "the logical NOT operator! is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaNOT [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The element-by-element result of the logical NOT operator! is the
valarray: ( 1 1 1 0 1 0 1 0 1 0 ).

operator%=

Bir dizi öğesinin öğelerini belirtilen valarray veya öğe türündeki bir değere bölmenin geri kalanını alır.

valarray<Type>& operator%=(const valarray<Type>& right);

valarray<Type>& operator%=(const Type& right);

Parametreler

right
valarray Bir öğe türünün veya değeri, valarrayişleneni valarray bölmek için işlenenle aynıdır.

Dönüş değeri

valarray öğeleri, tarafından rightişlenenin valarray öğe açısından bölümünden kalan öğeleridir.

Örnek

// valarray_class_op_rem.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 6 ), vaR ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  53;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -67;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  3*i+1;

   cout << "The initial valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial  right valarray is: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL %= vaR;
   cout << "The remainders from the element-by-element "
        << "division is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is: ( 53 -67 53 -67 53 -67 ).
The initial  right valarray is: ( 1 4 7 10 13 16 ).
The remainders from the element-by-element division is the
valarray: ( 0 -3 4 -7 1 -3 ).

operator&=

Bir dizideki öğelerin bit düzeyinde AND (&) değerini, belirtilen valarray bir öğedeki karşılık gelen öğelerle veya öğe türündeki bir değerle alır.

valarray<Type>& operator&=(const valarray<Type>& right);

valarray<Type>& operator&=(const Type& right);

Parametreler

right
valarray bit düzeyinde AND (&) tarafından işlenen ile valarraybirleştirilecek işlenenle valarray aynı öğe türünün veya değeri.

Dönüş değeri

valarray Öğeleri işlenenin bit tabanlı AND (&) valarray olanright

Açıklamalar

Bit düzeyinde bir işlem yalnızca ve intgibi char tam sayı veri türlerindeki bitleri işlemek için kullanılabilir. , , double, , voidlong double, , boolveya diğer daha karmaşık veri türlerinde floatçalışmaz.

Bit düzeyinde AND (&), tek tek bit düzeyindeki veri türüne uygulanır. Verilen bitler b1 ve b2, b1 & b2 her iki bit de 1 ise 1, en az bir bit 0 ise 0 olur.

Örnek

// valarray_class_op_bitand.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;
   for ( i = 0 ; i < 10 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL &= vaR;
   cout << "The element-by-element result of "
        << "the bitwise AND operator&= is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is:  ( 0 0 0 2 0 4 0 6 0 8 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 8 9 ).
The element-by-element result of the bitwise AND operator&= is the
valarray: ( 0 0 0 2 0 4 0 6 0 8 ).

operator>>=

bir valarray işlenenin her öğesi için bitleri belirtilen sayıda konumla veya bir saniyeyle valarraybelirtilen öğeye göre bir öğeye göre sağa kaydırıyor.

valarray<Type>& operator>>=(const valarray<Type>& right);

valarray<Type>& operator>>=(const Type& right);

Parametreler

right
Sağ kaydırma miktarını veya öğeleri öğeye göre sağ kaydırma miktarını gösteren değer valarray .

Dönüş değeri

valarray Öğeleri içinde rightbelirtilen miktarda sağa kaydırılmış olan bir.

Açıklamalar

İmzalı sayıların işaretleri korunur.

Örnek

// valarray_class_op_rs.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  64;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -64;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial operand valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The  right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL >>= vaR;
   cout << "The element-by-element result of "
        << "the right shift is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial operand valarray is: ( 64 -64 64 -64 64 -64 64 -64 ).
The  right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the right shift is the
valarray: ( 64 -32 16 -8 4 -2 1 -1 ).

operator<<=

Bir işlenenin her öğesi valarray için bitleri belirtilen sayıda konum veya bir saniye valarrayile belirtilen öğeye göre bir miktar sola kaydırıyor.

valarray<Type>& operator<<=(const valarray<Type>& right);

valarray<Type>& operator<<=(const Type& right);

Parametreler

right
Sol kaydırma miktarını veya valarray öğeleri öğeye göre sol kaydırma miktarını gösteren değer.

Dönüş değeri

valarray Öğeleri kaydırılan bir öğesinde rightbelirtilen miktarı bıraktı.

Açıklamalar

İmzalı sayıların işaretleri korunur.

Örnek

// valarray_class_op_ls.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial operand valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The  right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL <<= vaR;
   cout << "The element-by-element result of "
        << "the left shift"
        << endl << "on the operand array is the valarray:"
        << endl << "( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial operand valarray is: ( 1 -1 1 -1 1 -1 1 -1 ).
The  right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the left shift
on the operand array is the valarray:
( 1 -2 4 -8 16 -32 64 -128 ).

operator*=

Belirtilen valarray veya öğe türündeki bir değerin öğelerini bir işlenenle valarrayçarpar.

valarray<Type>& operator*=(const valarray<Type>& right);

valarray<Type>& operator*=(const Type& right);

Parametreler

right
valarray Bir öğe türünün veya değeri, işlecini valarray çarpmak için işlenenle aynı olan öğe valarraytürü.

Dönüş değeri

valarray öğeleri işlenenin ve rightöğelerinin öğe açısından çarpımları valarray olan bir.

Örnek

// valarray_op_emult.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL *= vaR;
   cout << "The element-by-element result of "
        << "the multiplication is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}
/* Output:
The initial valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial Right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the multiplication is the
valarray: ( 0 -1 4 -3 8 -5 12 -7 ).
*/

operator+

içindeki her öğeye artı uygulayan birli valarrayişleç. Normal aritmetik değerler için bu işlemin hiçbir etkisi yoktur.

valarray<Type> operator+() const;

Dönüş değeri

valarray Öğeleri işlenen dizisinin birli artı sonucu olan bir.

Örnek

// valarray_op_eplus.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 );
   valarray<int> vaPLUS ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;

   cout << "The initial valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   vaPLUS = +vaL;
   cout << "The element-by-element result of "
        << "the operator+ is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaPLUS [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is:  ( 0 0 -2 2 -4 4 -6 6 -8 8 ).
The element-by-element result of the operator+ is the
valarray: ( 0 0 -2 2 -4 4 -6 6 -8 8 ).

operator+=

belirtilen valarray veya öğe türündeki bir değerin öğelerini işlenene valarrayekler.

valarray<Type>& operator+=(const valarray<Type>& right);

valarray<Type>& operator+=(const Type& right);

Parametreler

right
valarray bir öğe türünün veya değeri, işlenene eklenecek olan işlenenle valarray aynı olan öğe valarraytürü.

Dönüş değeri

valarray Öğeleri işlenenin ve rightöğelerinin valarray öğe açısından toplamı olan bir.

Örnek

// valarray_op_eadd.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  2;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  -1;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial  right valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL += vaR;
   cout << "The element-by-element result of "
        << "the sum is the"
        << endl << "valarray: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is: ( 2 -1 2 -1 2 -1 2 -1 ).
The initial  right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the sum is the
valarray: ( 2 0 4 2 6 4 8 6 ).

operator-

içindeki her öğeye aritmetik bir olumsuzlama uygulayan bir valarraytekli işleç.

valarray<Type> operator-() const;

Dönüş değeri

valarray Öğeleri işlenenin öğelerinden valarrayaritmetik olarak olumsuzlanmış olan .

Örnek

// valarray_op_eminus.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 );
   valarray<int> vaMINUS ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  -i;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  i-1;

   cout << "The initial valarray is:  ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   vaMINUS = -vaL;
   cout << "The element-by-element result of "
        << "the operator- is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaMINUS [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is:  ( 0 0 -2 2 -4 4 -6 6 -8 8 ).
The element-by-element result of the operator- is the
valarray: ( 0 0 2 -2 4 -4 6 -6 8 -8 ).

operator-=

Belirtilen valarray veya öğe türündeki bir değerin öğelerini bir işlenenden valarrayçıkarır.

valarray<Type>& operator-=(const valarray<Type>& right);

valarray<Type>& operator-=(const Type& right);

Parametreler

right
valarray bir öğe türünün veya değeri, işlenenden valarrayçıkarılacak işlenenle valarray aynı olan öğe türünden çıkarılacaktır.

Dönüş değeri

valarray öğeleri işlenenin ve rightöğelerinin valarray öğe açısından farkı olan bir.

Örnek

// valarray_op_esub.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 8 ), vaR ( 8 );
   for ( i = 0 ; i < 8 ; i += 2 )
      vaL [ i ] =  10;
   for ( i = 1 ; i < 8 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 8 ; i++ )
      vaR [ i ] =  i;

   cout << "The initial valarray is: ( ";
      for (i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial  right valarray is: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL -= vaR;
   cout << "The element-by-element result of "
        << "the difference is the"
        << endl << "valarray: ( ";
      for ( i = 0 ; i < 8 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is: ( 10 0 10 0 10 0 10 0 ).
The initial  right valarray is: ( 0 1 2 3 4 5 6 7 ).
The element-by-element result of the difference is the
valarray: ( 10 -1 8 -3 6 -5 4 -7 ).

operator/=

İşlenen valarray öğe temelli bir öğeyi, belirtilen valarray veya öğe türündeki bir değerin öğelerine böler.

valarray<Type>& operator/=(const valarray<Type>& right);

valarray<Type>& operator/=(const Type& right);

Parametreler

right
valarray bir öğe türünün veya değeri, işlenene bölünecek işlenenle valarray aynı olan öğe türündedirvalarray.

Dönüş değeri

valarray Öğeleri, işlenenin tarafından bölünen rightöğe açısından bölüm valarray olan bir.

Örnek

// valarray_op_ediv.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<double> vaL ( 6 ), vaR ( 6 );
   for ( i = 0 ; i < 6 ; i += 2 )
      vaL [ i ] =  100;
   for ( i = 1 ; i < 6 ; i += 2 )
      vaL [ i ] =  -100;
   for ( i = 0 ; i < 6 ; i++ )
      vaR [ i ] =  2*i;

   cout << "The initial valarray is: ( ";
      for (i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The initial Right valarray is: ( ";
      for (i = 0 ; i < 6 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL /= vaR;
   cout << "The element-by-element result of "
        << "the quotient is the"
        << endl << "valarray: ( ";
      for (i = 0 ; i < 6 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial valarray is: ( 100 -100 100 -100 100 -100 ).
The initial Right valarray is: ( 0 2 4 6 8 10 ).
The element-by-element result of the quotient is the
valarray: ( inf -50 25 -16.6667 12.5 -10 ).

operator=

Değerleri doğrudan veya başka valarray bir valarray öğesinin parçası olarak ya da , gslice_array, mask_arrayveya indirect_arraytarafından belirtilen bir slice_arrayöğesine öğe atar.

valarray<Type>& operator=(const valarray<Type>& right);

valarray<Type>& operator=(valarray<Type>&& right);

valarray<Type>& operator=(const Type& val);

valarray<Type>& operator=(const slice_array<Type>& slicearray);

valarray<Type>& operator=(const gslice_array<Type>& gslicearray);

valarray<Type>& operator=(const mask_array<Type>& maskarray);

valarray<Type>& operator=(const indirect_array<Type>& indarray);

Parametreler

right
işlenenine valarray kopyalanacak valarray.

val
İşlenen valarrayöğelerinin atanacağı değer.

slicearray
işlenenine slice_array kopyalanacak valarray.

gslicearray
işlenenine gslice_array kopyalanacak valarray.

maskarray
işlenenine mask_array kopyalanacak valarray.

indarray
işlenenine indirect_array kopyalanacak valarray.

Dönüş değeri

İlk üye işleci, denetlenen sırayı tarafından rightdenetlenen dizinin bir kopyasıyla değiştirir.

İkinci üye işleci ilk işleçle aynıdır, ancak Rvalue başvuru bildirimcisi ile : &&.

Üçüncü üye işleci, denetlenen sıranın her öğesini bir val kopyasıyla değiştirir.

Kalan üye işleçleri, bağımsız değişkenleri tarafından seçilen denetlenen sıranın yalnızca tarafından operator[]oluşturulan öğelerinin yerini alır.

Değiştirme denetimli dizideki bir üyenin değeri, ilk denetlenen dizideki bir üyeye bağlıysa, sonuç tanımlanmamış olur.

Açıklamalar

Denetlenen sıranın uzunluğu değişirse, normalde sonuç tanımsız olur. Ancak bu uygulamada, etki yalnızca denetimli dizideki öğelere yönelik tüm işaretçileri veya başvuruları geçersiz kılmaya yöneliktir.

Örnek

// valarray_op_assign.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> va ( 10 ), vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 1 )
      va [ i ] = i;
   for ( i = 0 ; i < 10 ; i+=1 )
      vaR [ i ] = 10 -  i;

   cout << "The operand valarray va is:";
   for ( i = 0 ; i < 10 ; i++ )
      cout << " " << va [ i ];
   cout << endl;

   cout << "The operand valarray vaR is:";
      for ( i = 0 ; i < 10 ; i++ )
         cout << " " << vaR [ i ];
   cout << endl;

   // Assigning vaR to va with the first member function
   va = vaR;
   cout << "The reassigned valarray va is:";
   for ( i = 0 ; i < 10 ; i++ )
      cout << " " << va [ i ];
   cout << endl;

   // Assigning elements of value 10 to va
   // with the second member function
   va = 10;
   cout << "The reassigned valarray va is:";
      for ( i = 0 ; i < 10 ; i++ )
         cout << " " << va [ i ];
   cout << endl;
}

The operand valarray va is: 0 1 2 3 4 5 6 7 8 9
The operand valarray vaR is: 10 9 8 7 6 5 4 3 2 1
The reassigned valarray va is: 10 9 8 7 6 5 4 3 2 1
The reassigned valarray va is: 10 10 10 10 10 10 10 10 10 10

operator[]

Belirtilen dizinde veya belirtilen alt kümede bir öğeye veya değerine başvuru döndürür.

Type& operator[](size_t index);

slice_array<Type> operator[](slice slicearray);

gslice_array<Type> operator[](const gslice& gslicearray);

mask_array<Type> operator[](const valarray<bool>& boolarray);

indirect_array<Type> operator[](const valarray<size_t>& indarray);

Type operator[](size_t index) const;

valarray<Type> operator[](slice slicearray) const;

valarray<Type> operator[](const gslice& gslicearray) const;

valarray<Type> operator[](const valarray<bool>& boolarray) const;

valarray<Type> operator[](const valarray<size_t>& indarray) const;

Parametreler

index
Bir değer atanacak öğenin dizini.

slicearray
slice_array Seçilecek veya yeni valarraybir valarray öğesine döndürülecek bir alt kümeyi belirten bir öğesi.

gslicearray
gslice_array Seçilecek veya yeni valarraybir valarray öğesine döndürülecek bir alt kümeyi belirten bir öğesi.

boolarray
bool_array Seçilecek veya yeni valarraybir valarray öğesine döndürülecek bir alt kümeyi belirten bir öğesi.

indarray
indirect_array Seçilecek veya yeni valarraybir valarray öğesine döndürülecek bir alt kümeyi belirten bir öğesi.

Dönüş değeri

Belirtilen dizinde veya belirtilen alt kümede bir öğeye veya değerine başvuru.

Açıklamalar

Üye işleci, tarafından *thisdenetlenen öğeler arasından öğe dizilerini seçmenin çeşitli yollarını sağlamak için aşırı yüklenmiştir. Beş üye işleçlerden oluşan ilk grup, denetlenen sıranın operator= seçmeli olarak değiştirilmesine (dilimleme) izin vermek için çeşitli aşırı yüklemeleri (ve diğer atama işleçleri) ile birlikte çalışır. Seçili öğeler mevcut olmalıdır.

1 veya 2 olarak tanımlanan kullanılarak _ITERATOR_DEBUG_LEVEL derlendiğinde, sınırlarının valarraydışındaki bir öğeye erişmeye çalışırsanız bir çalışma zamanı hatası oluşur. Daha fazla bilgi için bkz . İşaretli yineleyiciler.

Örnek

bildirme ve kullanma operator[]örnekleri için slice::slice ve gslice::gslice örneklerine bakın.

operator^=

Belirtilen valarray veya öğe türünün değerine sahip bit valarray düzeyinde özel veya (^) değerini alır.

valarray<Type>& operator^=(const valarray<Type>& right);

valarray<Type>& operator^=(const Type& right);

Parametreler

right
valarray Bit tabanlı özel veya (XOR) işleci^ () tarafından işlenen ile birleştirilecek işlenenle valarray valarrayaynı öğe türünün veya değeri.

Dönüş değeri

valarray Öğeleri işlenenin bit tabanlı özel veya (XOR) valarray olan ve right.

Açıklamalar

XOR olarak adlandırılan ve işleci ^tarafından belirtilen bit tabanlı özel veya şu semantiği içerir: Verilen bitler b1 ve b2, b1 ^ b2 öğelerden tam olarak biri 1 ise 1, her iki öğe de 0 veya 1 ise 0'dır.

Örnek

// valarray_op_exor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
    using namespace std;
    int i;

    valarray<int> vaL ( 10 ), vaR ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        vaL [ i ] =  1;
    for ( i = 1 ; i < 10 ; i += 2 )
        vaL [ i ] =  0;
    for ( i = 0 ; i < 10 ; i += 3 )
        vaR [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 3 )
        vaR [ i ] =  i-1;
    for ( i = 2 ; i < 10 ; i += 3 )
        vaR [ i ] =  i-1;

    cout << "The initial operand valarray is:  ( ";
        for (i = 0 ; i < 10 ; i++ )
            cout << vaL [ i ] << " ";
    cout << ")." << endl;

    cout << "The  right valarray is: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaR [ i ] << " ";
    cout << ")." << endl;

    vaL ^= vaR;
    cout << "The element-by-element result of "
        << "the bitwise XOR operator^= is the"
        << endl << "valarray: ( ";
        for (i = 0 ; i < 10 ; i++ )
            cout << vaL [ i ] << " ";
    cout << ")." << endl;
}

The initial operand valarray is:  ( 1 0 1 0 1 0 1 0 1 0 ).
The  right valarray is: ( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise XOR operator^= is the
valarray: ( 1 0 0 3 2 4 7 6 6 9 ).

operator|=

Bir dizideki öğelerin bit düzeyinde OR (|) değerini, belirtilen valarray bir içindeki karşılık gelen öğelerle veya öğe türündeki bir değerle alır.

valarray<Type>& operator|=(const valarray<Type>& right);

valarray<Type>& operator|=(const Type& right);

Parametreler

right
valarray bit düzeyinde OR (|) tarafından işlenen ile valarraybirleştirilecek işlenenle valarray aynı öğe türünün veya değeri.

Dönüş değeri

valarray öğeleri tarafından rightişlenenin valarray öğe açısından bit tabanlı OR (|) olan bir.

Açıklamalar

Bit düzeyinde bir işlem yalnızca ve intgibi char tam sayı veri türlerindeki bitleri işlemek için kullanılabilir. , , double, , voidlong double, , boolveya diğer daha karmaşık veri türlerinde floatçalışmaz.

Bit düzeyinde OR (|), tek tek bit düzeyindeki veri türüne uygulanır. Verilen bitler b1 ve b2, b1 | b2 bitlerden en az biri 1 ise 1, her iki bit de 0 ise 0 olur.

Örnek

// valarray_class_op_bitor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> vaL ( 10 ), vaR ( 10 );
   for ( i = 0 ; i < 10 ; i += 2 )
      vaL [ i ] =  1;
   for ( i = 1 ; i < 10 ; i += 2 )
      vaL [ i ] =  0;
   for ( i = 0 ; i < 10 ; i += 3 )
      vaR [ i ] =  i;
   for ( i = 1 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;
   for ( i = 2 ; i < 10 ; i += 3 )
      vaR [ i ] =  i-1;

   cout << "The initial operand valarray is:"
        << endl << "( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;

   cout << "The  right valarray is:"
        << endl << "( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << vaR [ i ] << " ";
   cout << ")." << endl;

   vaL |= vaR;
   cout << "The element-by-element result of "
        << "the bitwise OR"
        << endl << "operator|= is the valarray:"
        << endl << "( ";
      for (i = 0 ; i < 10 ; i++ )
         cout << vaL [ i ] << " ";
   cout << ")." << endl;
}

The initial operand valarray is:
( 1 0 1 0 1 0 1 0 1 0 ).
The  right valarray is:
( 0 0 1 3 3 4 6 6 7 9 ).
The element-by-element result of the bitwise OR
operator|= is the valarray:
( 1 0 1 3 3 4 7 6 7 9 ).

operator~

içindeki her öğenin değerlerinin bit düzeyinde tamamlayıcısını alan bir valarraytekli işleç.

valarray<Type> operator~() const;

Dönüş değeri

işleneninin valarray öğe değerlerinin bit düzeyinde olmayan tamamlayıcısı olan değerlerin valarraydeğeri.

Açıklamalar

Bit düzeyinde bir işlem yalnızca ve intgibi char tam sayı türlerindeki bitleri işleyebilir. , , double, , voidlong double, , boolveya diğer daha karmaşık veri türlerinde floatçalışmaz.

Bit düzeyinde olmayan tamamlayıcı işleci ~ , tek tek bit düzeyindeki veri türüne uygulanır. Verilen bit b, ~b 0 ise b 1, 1 ise b 0'dır.

Örnek

// valarray_op_bitnot.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
    using namespace std;
    int i;

    valarray<unsigned short int> vaL1 ( 10 );
    valarray<unsigned short int> vaNOT1 ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        vaL1 [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        vaL1 [ i ] =  5*i;

    cout << "The initial valarray <unsigned short int> is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaL1 [ i ] << " ";
    cout << ")." << endl;

    vaNOT1 = ~vaL1;
    cout << "The element-by-element result of "
        << "the bitwise NOT operator~ is the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT1 [ i ] << " ";
    cout << ")." << endl << endl;

    valarray<int> vaL2 ( 10 );
    valarray<int> vaNOT2 ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        vaL2 [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        vaL2 [ i ] =  -2 * i;

    cout << "The initial valarray <int> is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaL2 [ i ] << " ";
    cout << ")." << endl;

    vaNOT2 = ~vaL2;
    cout << "The element-by-element result of "
        << "the bitwise NOT operator~ is the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT2 [ i ] << " ";
    cout << ")." << endl;

    // The negative numbers are represented using
    // the two's complement approach, so adding one
    // to the flipped bits returns the negative elements
    vaNOT2 = vaNOT2 + 1;
    cout << "The element-by-element result of "
        << "adding one"
        << endl << "is the negative of the "
        << "original elements the"
        << endl << "valarray: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << vaNOT2 [ i ] << " ";
    cout << ")." << endl;
}

The initial valarray <unsigned short int> is:  ( 0 5 2 15 4 25 6 35 8 45 ).
The element-by-element result of the bitwise NOT operator~ is the
valarray: ( 65535 65530 65533 65520 65531 65510 65529 65500 65527 65490 ).

The initial valarray <int> is:  ( 0 -2 2 -6 4 -10 6 -14 8 -18 ).
The element-by-element result of the bitwise NOT operator~ is the
valarray: ( -1 1 -3 5 -5 9 -7 13 -9 17 ).
The element-by-element result of adding one
is the negative of the original elements the
valarray: ( 0 2 -2 6 -4 10 -6 14 -8 18 ).

resize

içindeki valarray öğelerin sayısını belirtilen bir sayıya değiştirir.

void resize(
    size_t new_size);

void resize(
    size_t new_size,
    const Type val);

Parametreler

new_size
Yeniden boyutlandırılan valarrayiçindeki öğe sayısı.

val
Yeniden boyutlandırılan valarrayöğesinin öğelerine verilecek değer.

Açıklamalar

İlk üye işlevi, öğeleri varsayılan oluşturucularıyla başlatır.

Denetlenen dizideki öğelere yönelik tüm işaretçiler veya başvurular geçersiz kılındı.

Örnek

Aşağıdaki örnekte üye işlevinin kullanımı gösterilmektedir valarray::resize .

// valarray_resize.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main()
{
    using namespace std;
    int i;
    size_t size1, sizeNew;

    valarray<int> va1(10);
    for (i = 0; i < 10; i+=1)
        va1[i] = i;

    cout << "The valarray contains ( ";
        for (i = 0; i < 10; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;

    size1 = va1.size();
    cout << "The number of elements in the valarray is: "
         << size1  << "." <<endl << endl;

    va1.resize(15, 10);

    cout << "The valarray contains ( ";
        for (i = 0; i < 15; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;
    sizeNew = va1.size();
    cout << "The number of elements in the resized valarray is: "
         << sizeNew  << "." <<endl << endl;
}

The valarray contains ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray is: 10.

The valarray contains ( 10 10 10 10 10 10 10 10 10 10 10 10 10 10 10 ).
The number of elements in the resized valarray is: 15.

shift

Bir içindeki valarray tüm öğeleri belirtilen sayıda yere kaydırır.

valarray<Type> shift(int count) const;

Parametreler

count
Öğelerin ileri kaydırılacağı yer sayısı.

Dönüş değeri

İşlenen içindeki konumlarıyla valarraykarşılaştırıldığında tüm öğelerin öğesinin valarrayönüne doğru veya sola doğru hareket ettirildiği count yeni valarray bir yeni.

Açıklamalar

pozitif değeri count , öğeleri sıfır dolguyla sola count kaydırır.

negatif değeri count , öğeleri sıfır dolguyla doğru count yerlere kaydırır.

Örnek

// valarray_shift.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
   using namespace std;
   int i;

   valarray<int> va1 ( 10 ), va2 ( 10 );
   for ( i = 0 ; i < 10 ; i += 1 )
      va1 [ i ] =  i;
   for ( i = 0 ; i < 10 ; i += 1 )
      va2 [ i ] = 10 -  i;

   cout << "The operand valarray va1(10) is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va1 [ i ] << " ";
   cout << ")." << endl;

   // A positive parameter shifts elements left
   va1 = va1.shift ( 4 );
   cout << "The shifted valarray va1 is: va1.shift (4) = ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va1 [ i ] << " ";
   cout << ")." << endl;

   cout << "The operand valarray va2(10) is: ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va2 [ i ] << " ";
   cout << ")." << endl;

   // A negative parameter shifts elements right
   va2 = va2.shift ( - 4 );
   cout << "The shifted valarray va2 is: va2.shift (-4) = ( ";
      for ( i = 0 ; i < 10 ; i++ )
         cout << va2 [ i ] << " ";
   cout << ")." << endl;
}

The operand valarray va1(10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The shifted valarray va1 is: va1.shift (4) = ( 4 5 6 7 8 9 0 0 0 0 ).
The operand valarray va2(10) is: ( 10 9 8 7 6 5 4 3 2 1 ).
The shifted valarray va2 is: va2.shift (-4) = ( 0 0 0 0 10 9 8 7 6 5 ).

size

içindeki valarrayöğe sayısını bulur.

size_t size() const;

Dönüş değeri

İşlenen valarrayiçindeki öğe sayısı.

Örnek

Aşağıdaki örnekte üye işlevinin kullanımı gösterilmektedir valarray::size .

// valarray_size.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main()
{
    using namespace std;
    int i;
    size_t size1, size2;

    valarray<int> va1(10), va2(12);
    for (i = 0; i < 10; i += 1)
        va1[i] =  i;
    for (i = 0; i < 10; i += 1)
        va2[i] =  i;

    cout << "The operand valarray va1(10) is: ( ";
        for (i = 0; i < 10; i++)
            cout << va1[i] << " ";
    cout << ")." << endl;

    size1 = va1.size();
    cout << "The number of elements in the valarray va1 is: va1.size = "
         << size1  << "." <<endl << endl;

    cout << "The operand valarray va2(12) is: ( ";
        for (i = 0; i < 10; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;

    size2 = va2.size();
    cout << "The number of elements in the valarray va2 is: va2.size = "
         << size2  << "." << endl << endl;

    // Initializing two more elements to va2
    va2[10] = 10;
    va2[11] = 11;
    cout << "After initializing two more elements,\n"
         << "the operand valarray va2(12) is now: ( ";
        for (i = 0; i < 12; i++)
            cout << va2[i] << " ";
    cout << ")." << endl;
    cout << "The number of elements in the valarray va2 is still: "
         << size2  << "." << endl;
}

The operand valarray va1(10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va1 is: va1.size = 10.

The operand valarray va2(12) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The number of elements in the valarray va2 is: va2.size = 12.

After initializing two more elements,
the operand valarray va2(12) is now: ( 0 1 2 3 4 5 6 7 8 9 10 11 ).
The number of elements in the valarray va2 is still: 12.

sum

Sıfır olmayan uzunluktaki valarray tüm öğelerin toplamını belirler.

Type sum() const;

Dönüş değeri

İşlenen öğelerinin valarraytoplamı.

Açıklamalar

Uzunluk birden büyükse, üye işlevi sınıfının Typeöğe çiftleri arasında uygulayarak operator+= toplama değer ekler. Bu, işlecin türündeki Typeöğeler için sağlanması gerektiği anlamına gelir.

Örnek

// valarray_sum.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
    using namespace std;
    int i;
    int sumva = 0;

    valarray<int> va ( 10 );
    for ( i = 0 ; i < 10 ; i+=1 )
        va [ i ] =  i;

    cout << "The operand valarray va (10) is: ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << va [ i ] << " ";
    cout << ")." << endl;

    sumva = va.sum ( );
    cout << "The sum of elements in the valarray is: "
        << sumva  << "." <<endl;
}

The operand valarray va (10) is: ( 0 1 2 3 4 5 6 7 8 9 ).
The sum of elements in the valarray is: 45.

swap

İki valarray nesnenin öğelerini değiştirir.

void swap(valarray& right);

Parametreler

right
valarray Değiştirilecek öğeleri sağlayan.

Açıklamalar

Üye işlevi, ve arasında *this rightdenetlenen dizileri değiştirir. Bunu sabit süre içinde yapar, hiçbir özel durum oluşturmaz ve denetlenen iki dizideki öğelere hiçbir başvuru, işaretçi veya yineleyiciyi geçersiz kılmaz.

valarray

Belirli bir valarray boyutta veya belirli bir değerin öğeleriyle ya da başka bir veya başka valarray bir alt kümesinin valarraykopyası olarak oluşturur.

valarray();

explicit valarray(
    size_t count);

valarray(
    const Type& val,
    size_t count);

valarray(
    const Type* ptr,
    size_t count);

valarray(
    const valarray<Type>& right);

valarray(
    const slice_array<Type>& sliceArray);

valarray(
    const gslice_array<Type>& gsliceArray);

valarray(
    const mask_array<Type>& maskArray);

valarray(
    const indirect_array<Type>& indArray);

valarray(
    valarray<Type>&& tight);

valarray(
    initializer_list<Type> iList);

Parametreler

count
içinde valarrayolacak öğelerin sayısı.

val
içindeki öğeleri valarraybaşlatırken kullanılacak değer.

ptr
içindeki öğeleri başlatmak için kullanılacak değerlerin işaretçisi valarray.

right
Yeni valarrayöğesini başlatmak için var olan valarray bir .

sliceArray
slice_array Öğe değerleri, oluşturulmakta olan öğelerinin valarray başlatılmasında kullanılacak olan.

gsliceArray
gslice_array Öğe değerleri, oluşturulmakta olan öğelerinin valarray başlatılmasında kullanılacak olan.

maskArray
mask_array Öğe değerleri, oluşturulmakta olan öğelerinin valarray başlatılmasında kullanılacak olan.

indArray
indirect_array Öğe değerleri, oluşturulmakta olan öğelerinin valarray başlatılmasında kullanılacak olan.

iList
initializer_list Kopyalanacak öğeleri içeren.

Açıklamalar

İlk (varsayılan) oluşturucu, nesnesini boş valarraybir olarak başlatır. Sonraki üç oluşturucunun her biri nesnesini aşağıdaki gibi öğelerden birine valarray count başlatır:

• Açık valarray(size_t count)için, her öğe varsayılan oluşturucu ile başlatılır.

• için valarray(const Type& val, count)her öğe ile valbaşlatılır.

• için valarray(const Type* ptr, count)konumundaki I öğesi ile ptr[I]başlatılır.

Kalan her oluşturucu, nesnesini bağımsız değişkende belirtilen alt küme tarafından belirlenen bir valarray<Type> nesneye başlatır.

Son oluşturucu, bir sonraki son ile aynıdır, ancak Rvalue başvuru bildirimcisi ile: &&.

Örnek

// valarray_ctor.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main()
{
    using namespace std;
    int i;

    // The second member function
    valarray<int> va(10);
    for (auto i : va){
        va[i] = 2 * (i + 1);
    }

    cout << "The operand valarray va is:\n(";
    for (auto i : va) {
        cout << " " << va[i];
    }
    cout << " )" << endl;

    slice Slice(2, 4, 3);

    // The fifth member function
    valarray<int> vaSlice = va[Slice];

    cout << "The new valarray initialized from the slice is vaSlice =\n"
        << "va[slice( 2, 4, 3)] = (";
    for (int i = 0; i < 3; i++) {
        cout << " " << vaSlice[i];
    }
    cout << " )" << endl;

    valarray<int> va2{{ 1, 2, 3, 4 }};
    for (auto& v : va2) {
        cout << v << " ";
    }
    cout << endl;
}

The operand valarray va is:
( 0 2 2 2 2 2 2 2 2 2 )
The new valarray initialized from the slice is vaSlice =
va[slice( 2, 4, 3)] = ( 0 0 0 )
1 2 3 4

value_type

içinde depolanan öğenin türünü temsil eden bir valarraytür.

typedef Type value_type;

Açıklamalar

türü, şablon parametresi Typeiçin bir eş anlamlıdır.

Örnek

// valarray_value_type.cpp
// compile with: /EHsc
#include <valarray>
#include <iostream>

int main( )
{
    using namespace std;
    int i;
    valarray<int> va ( 10 );
    for ( i = 0 ; i < 10 ; i += 2 )
        va [ i ] =  i;
    for ( i = 1 ; i < 10 ; i += 2 )
        va [ i ] =  -1;

    cout << "The initial operand valarray is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << va [ i ] << " ";
    cout << ")." << endl;

    // value_type declaration and initialization:
    valarray<int>::value_type Right = 10;

    cout << "The declared value_type Right is: "
            << Right << endl;
    va *= Right;
    cout << "The resulting valarray is:  ( ";
        for ( i = 0 ; i < 10 ; i++ )
            cout << va [ i ] << " ";
    cout << ")." << endl;
}

The initial operand valarray is:  ( 0 -1 2 -1 4 -1 6 -1 8 -1 ).
The declared value_type Right is: 10
The resulting valarray is:  ( 0 -10 20 -10 40 -10 60 -10 80 -10 ).

Ayrıca bkz.

C++ Standart Kitaplığı'nda iş parçacığı güvenliği