c++指数函数怎么表达

Posted 2023-05-06

rt，具体点

1、#include <math.h>

pow(a,b)表示a的b次方；

2、指数函数是重要的基本初等函数之一。一般地，y=ax函数(a为常数且以a>0，a≠1)叫做指数函数，函数的定义域是 R 。

扩展资料：

C语言函数介绍：

C语言是一种计算机程序设计语言。它既具有高级语言的特点，又具有汇编语言的特点。其可以作为系统设计语言，编写工作系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用程序。

C语言是一种程序设计的入门语言。由于C语言的语句中没有提供直接计算sin或cos函数的语句，会造成编写程序困难；但是函数库提供了sin和cos函数，可以拿来直接调用。显示一段文字，我们在C语言中找不到显示语句，只能使用库函数printf。

参考资料来源：百度百科-C语言函数

参考技术A C里面函数原型是double pow(double,double)，需要包含math.h。
C++里面推荐这样用（包含ISO C++从C继承的数学函数库，但头文件不带.h扩展名且前面加c，需要用namespace std，函数原型与C中相同）：
#include<cmath>
//添加需要包含的头文件...
using namespace std;
int main()

double d,a=2,b=3;
d=pow(a,b);
//d=a^b
//添加代码...
return 0;

另外如果使用底数为e，可以用double exp(double)，用法与以上类似。 参考技术B 指针函数是指带指针的函数，即本质是一个函数。函数返回类型是某一类型的指针
类型标识符 *函数名(参数表)
int *f(x，y);

首先它是一个函数，只不过这个函数的返回值是一个地址值。函数返回值必须用同类型的指针变量来接受，也就是说，指针函数一定有函数返回值，而且，在主调函数中，函数返回值必须赋给同类型的指针变量。 参考技术C 指数函数是一个公式，C++文件库中本身就有的，不过使用时要先声明引用，即加上一句#include<math.h>,然后指数的函数是pow(x,y),即x的y次方 参考技术D a^x = e^x ln(a)

C++ lambda表达式

lambda表达式又称匿名函数（Anonymous function），其构造了一个可以在其作用范围内捕获变量的函数对象。

lambda表达式实际为一个仿函数functor，编译器后会生成一个匿名类（注：这个类重载了()运算符）

与普通函数指针相比，Lambda表达式可以包含数据成员，也就是说它是可以有状态的。下面举一个简单的例子说明一下：

int sum = 0;
std::vector<int> arry =  1,2,3,4,5 ;
std::for_each(begin(arry), end(arry), [&sum](int x)sum += x;);

上述代码被编译器展开后，会变成：

struct lambda_b53d8cae67476f0e5f04d9defa3a2e2b

private:
    int* m_pSum;
public:
    lambda_b53d8cae67476f0e5f04d9defa3a2e2b(int* pSum)
    
        m_pSum = pSum;
    

    void operator()(int x) const 
    
        *m_pSum += x;
    
;


int sum = 0;
std::vector<int> arry =  1,2,3,4,5 ;
lambda_b53d8cae67476f0e5f04d9defa3a2e2b obj(&sum);
std::for_each(begin(arry), end(arry), obj);

 

lambda表示式的结构

从C++11起，开始提供了匿名函数的支持，一个lambda表达式形如：

[capture] (parameters) specifiers -> return_type body

capture

捕获的外部变量列表，通过逗号分隔，可进行传值捕获或者引用捕获，lambda表达式与这些捕获的外部变量会构成一个闭包（Closure），外部变量为闭包的成员变量

int g_Value = 0;
class CLambda

protected:
    int m_Value;
public:
    void Test1(int InValue)
    
        int Value = 0;
        auto a1 = [](int x) /*仅能访问全局外部变量*/;
        auto a2 = [Value](int x) /*值传递局部变量Value*/;
        auto a3 = [this](int x) /*值传递this指针*/;
        auto a4 = [&Value](int x) /*引用传递局部变量Value*/;
        auto a5 = [=](int x) /*值传递所有可访问的外部变量*/;
        auto a6 = [&](int x) /*引用传递所有可访问的外部变量*/;
        auto a7 = [=, &Value](int x) /*引用传递局部变量Value，值传递所有其他可访问的外部变量*/;
        auto a8 = [&, Value](int x) /*值传递局部变量Value，引用传递所有其他可访问的外部变量*/;
    
;

① 全局变量、静态变量不用显示写在外部变量列表中，可直接在lambda表达式中读写

② 传值捕获的外部变量是一个副本，默认情况下在lambda表达式中是只读的，若想修改该副本，需要在lambda表达式上添加mutable关键字  如：auto a2 = [Value](int x) mutable Value++;;

---------------------------------------------------------------------------

在C++中，mutable是为了突破const的限制而设置的，用来修饰类的非静态、非常量的数据成员，让被修饰的变量永远处于可变的状态

mutable的作用有两点：
a. 保持常量对象中大部分数据成员仍然是“只读”的情况下，实现对个别数据成员的修改；
b. 使类的const函数可以修改其mutable数据成员。

---------------------------------------------------------------------------

③ 在类的非静态成员函数中定义的lambda表达式可以通过捕捉this指针，来访问对象的成员变量和成员函数

④ c++14中增加广义捕获（Generalized capture）：即在捕获子句中增加并初始化新的变量，该变量不需要在lambda表达式所处的闭包域中存在；

即使在闭包域中存在也会被新变量覆盖。新变量类型由它的初始化表达式推导得到。一个用途是可以从闭包域中捕获只供移动的变量并使用它。

int Value = 0;
auto a1 = [Value = 100]  return Value; ;// 捕获子句中定义的Value变量会覆盖同名的外部局部变量
int result = a1(); // result=100

std::vector<int> Vout =  10, 20, 30, 40, 50 ;
auto a2 = [Vin = std::move(Vout)] // 将外部局部变量Vout移动到Vin变量，避免发生拷贝耗时操作
    int sum = 0;
    for (auto n : Vin)
    
        sum += n;
    

    return sum;
;

int result2 = a2(); // result2=150

 

parameters

lambda表达式自己的参数列表

1. 若lambda函数没有形参且没有被mutable等修饰，则参数的空圆括号可以省略

如：auto a = [] ++g_Value; ;

2. c++14支持auto类型的形参

auto a = [](auto x, auto y) return x + y;;

//相当于定义了模板类型()运算符的函数对象
struct unnamed_lambda                            

  template<typename T, typename U> 
  auto operator()(T x, U y) const return x + y;
 a;

3. c++14支持可变参数模板

int foo(int n1, int n2, bool flag)

    return flag ? n1 : n2;


auto a = [](auto&&... params) //可变参数的模板

    return (foo(std::forward<decltype(params)>(params)...));
;
int result = a(1, 2, true); //result=1

4. 与普通函数相比，lambda表达式的参数有如下限制

① 参数不能有缺省值   如：int Add1(int a, int b=10) 

② 不能有可变长参数列表  如：int  Add2(int count, ...)

③ 不能有无名参数  如：int Add3(int a, int b, int)  // 第三个参数为无名参数，用于以后扩展

 

specifiers

说明符，可选。如上文中的mutable

 

return_type

返回类型

在以下情况下，可省略return_type

① 返回值为void类型  如：auto a = [](int x) x = 100;;  //返回值类型为void

② 所有返回语句用decltype都能检测到同一类型  如：auto a = [](int x, float y) if (x > 0) return x + y;  return y; ;  //返回值类型推导为float

 

使用lambda表达式

lambda表达式实际为一个函数对象，在使用时要注意lambda表达式以及被其捕获的外部变量的生命周期

把匿名函数存储在变量，当做有名函数来使用

lambda表达式的数据类型是函数对象，可用auto类型、std::function模板类型（需#include <functional>）进行保存和调用

当捕获外部变量列表为空时，也可用普通函数指针进行保存和调用

int Value = 0;

auto a1 = [&Value](int x) Value = x;;
std::function<float(int,float)> a2 = [Value](int x, float y)  return x + y; ; //需要#include <functional>
a1(100);
a2(100, 200.0f);

// lambda函数的捕获外部变量列表为空时，可使用普通函数指针来保存
int(*func1_ptr)(int) = [](int x) return x; ;
bool(*func2_ptr)(int, int) = [](int x, int y)  return x > y; ;
int n = func1_ptr(1);
bool b = func2_ptr(1, 2);

 

悬挂引用问题

lambda表达式的闭包含有局部变量的引用（悬挂引用  Dangling references），在超出创建它的作用域之外的地方被使用的话，将引发内存越界访问

std::function<int()> a;

    int Value = 0;
    a = [&Value] return Value; ;

        
a(); // 局部变量Value超过作用域，已被回收，调用lambda表达式将产生内存越界访问

 

参考

C++ 中的 LAMBDA 表达式

Lambda 表达式 (C++11 起)