Verwenden der STL-Funktionen sqrt und pow in Visual C++

In diesem Artikel wird die Verwendung von STL sqrt und pow Funktionen in Visual C++ veranschaulicht. Die Informationen in diesem Artikel gelten nur für nicht verwalteten Visual C++-Code.

Ursprüngliche Produktversion: Visual C++
Ursprüngliche KB-Nummer: 157942

Erforderliche Header

<valarray>
<cmath>

Prototyp

// sqrt
template<class T>
inline valarray<T> sqrt(const valarray<T>& x);

// pow
template<class T>
inline valarray<T> pow(const valarray<T>& x, const valarray<T>& y);

template<class T>
inline valarray<T> pow(const valarray<T> x, const T& y);

template<class T>
inline valarray<T> pow(const T& x, const valarray<T>& y);

Beschreibung

In diesem Artikel wird die Verwendung von STL sqrt() und pow() Funktionen anhand des Beispielcodes veranschaulicht. sqrt() gibt ein Objekt der -Klasse <valarrayT>zurück, deren Elemente am Index I die Quadratwurzel von x[I]sind. pow() verfügt über drei Vorlagenfunktionen. Die erste Vorlagenfunktion gibt ein Objekt der -Klasse valarray<T>zurück, deren Elemente am Index I auf die Potenz von y[I]erhöht werdenx[I]. Die zweite Vorlagenfunktion speichert in Element I, x[I] das auf die Potenz von y erhöht wird. Die dritte Vorlagenfunktion speichert im Element I x , das auf die Potenz von y[I]erhöht wird. Die gleichen Informationen zu sqrt und powfinden Sie unter sqrt und pow.

Beispielcode

//////////////////////////////////////////////////////////////////////
// Compile options needed: /GX
// main.cpp : Illustrates the use of STL sqrt() and pow() functions.
// Functions:
//    sqrt, pow
// of Microsoft Product Support Services,
// Copyright (c) 1996 Microsoft Corporation. All rights reserved.
//////////////////////////////////////////////////////////////////////

#include <iostream>                 // for i/o functions
#include <valarray>                 // for valarray
#include <cmath>                    // for sqrt() and pow()

#if _MSC_VER > 1020   // if VC++ version is > 4.2
   using namespace std;  // std c++ libs implemented in std
#endif

#define ARRAY_SIZE  3               // array size

void main()

{
    // Set val_array to contain values 1, 4, 9 for the following test
    valarray<double> val_array(ARRAY_SIZE);

    for (int i = 0; i < ARRAY_SIZE; i++)
        val_array[i] = (i+1) * (i+1);

    // Display the size of val_array
    cout << "Size of val_array = " << val_array.size() << endl;

    // Display the values of val_array before calling sqrt() and pow().
    cout << "The values in val_array:" << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << val_array[i] << "    ";
    cout << endl << endl;

    // Initialize rev_valarray that is the reverse of val_array.
    valarray<double> rev_valarray(ARRAY_SIZE);
    for (i = 0; i < ARRAY_SIZE; i++)
        rev_valarray[i] = val_array[ARRAY_SIZE - i - 1];

    // Display the size of rev_valarray.
    cout << "Size of rev_valarray = " << rev_valarray.size() << endl;

    // Display the values of rev_valarray.
    cout << "The values in rev_valarray:" << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << rev_valarray[i] << "    ";
    cout << endl << endl;

    // rvalue_array to hold the return value from calling the sqrt() and
    // pow() functions.
    valarray<double> rvalue_array;

    // ----------------------------------------------------------------
    // sqrt() - display the content of rvalue_array
    // ----------------------------------------------------------------

    // Display the result of val_array after calling sqrt().
    rvalue_array = sqrt(val_array);
    cout << "The result of val_array after calling sqrt():" << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << "     ";
    cout << endl << endl;

    // ----------------------------------------------------------------
    // pow() - display the content of rvalue_array
    // ----------------------------------------------------------------

    // This template function returns an object of class valarray<T>,
    // each of whose elements at I is x[I] raised to the power of y[I].
    rvalue_array = pow(val_array, rev_valarray);
    cout << "The result after calling pow(val_array, rev_valarray):"
         << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << "     ";
    cout << endl << endl;

    // This template function stores in element I x[I] raised to the
    // power of y, where y=2.0.
    rvalue_array = pow(val_array, 2.0);
    cout << "The result after calling pow(val_array, 2.0):" << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << "     ";
    cout << endl << endl;

    // This template function stores in element I x raised to the
    // y[I] power, where x=2.0.
    rvalue_array = pow(2.0, val_array);
    cout << "The result after calling pow(2.0, val_array):" << endl;
    for (i = 0; i < ARRAY_SIZE; i++)
        cout << rvalue_array[i] << "     ";
    cout << endl << endl;
}

Programmausgabe

Size of val_array = 3
The values in val_array:
1    4    9

Size of rev_valarray = 3
The values in rev_valarray:
9    4    1

The result of val_array after calling sqrt():
1     2     3

The result after calling pow(val_array, rev_valarray):
1     256     9

The result after calling pow(val_array, 2.0):
1     16     81

The result after calling pow(2.0, val_array):
2     16     512