没有合适的资源？快使用搜索试试~ 我知道了~

首页C++ Lambda Story - From C++98 to C++20.pdf

现代C特性：Lambda表达式详解 - C 98至C 20.pdf

Lambda

8 下载量 16 浏览量更新于2023-11-24 评论收藏 1017KB PDF 举报

身份认证购VIP最低享 7 折!

领优惠券(最高得80元）

试读

92页

《C Lambda Story - From C 98 to C 20》是一本适合所有喜欢了解现代C特性，尤其是Lambda表达式的C开发人员的书籍。该书于2019年3月25日推出第一版，并在2020年1月5日、4月17日、4月30日、6月19日进行了多次校对和更新。书中包括了C03、C11、C14、C17和C20等版本的Lambda技术列表、五大Lambda功能列表、代码证书等内容。读者如果发现任何错误，可通过提供的邮箱或反馈页面联系作者。此外，书中的代码遵循知识共享许可，可在在线编译器中进行语法高亮和限制。整体而言，该书内容丰富，适合C开发人员学习和参考。

资源详情

资源评论

资源推荐

C++ Lambda Story - From C++98 to C++20.md 1/1/2023

15 / 92

但是，你可以拷⻉ Lambda：

代码 2-4 拷⻉ Lambda

#include <type_traits>

int main() {

const auto firstLam = [](int x) noexcept {

return x * 2;

};

const auto secondLam = firstLam;

static_assert(std::is_same<decltype(firstLam), decltype(secondLam)>::value,

"must be the same");

}

如果拷⻉了⼀个 Lambda（实际上发⽣的是拷⻉构造），它的状态也会被拷⻉过来。

这⼀点对于捕获对象来说很重要。

因为，⼀个闭包类型会存储捕获的对象作为其成员字段。

所以，当进⾏ Lambda 拷⻉时，会拷⻉那些数据成员字段。

在 C++20 中，⽆状态 Lambda 会拥有默认的构造器和拷⻉赋值。

3. 调⽤操作符

我们传入 Lambda 中的参数部分，会被“转译”为相应闭包类型的调⽤操作符的参数。

默认情况下，在 C++11 中，他会被“转译”为⼀个常量内联成员函数。

例如

auto lam = [](double param) { /*do something*/ };

将被编译器展开为：

struct __anonymousLambda {

inline void operator()(double param) const { /*do something*/ }

};

重载

有⼀件事情值得提⼀下，那就是当你定义了⼀个 lambda 时，你不能创建它的任何重载形式来传入不同的参

数。

C++ Lambda Story - From C++98 to C++20.md 1/1/2023

16 / 92

// ⽆法编译

auto lam = [](double param) { /* do something */ };

auto lam = [](int param) { /* do something */ };

上⾯的代码将⽆法通过编译，因为编译器会将他们“转译”为⼀个仿函数，当然这就意味着⽆法重新定义⼀个相

同的变量。

但是，你可以在⼀个仿函数中定义两个调⽤操作符的重载形式，这是允许的：

struct MyFunctor {

inline void operator()(double param) { /* do something */ };

inline void operator()(int param) { /* do something */ };

};

MyFunctor 现在就可以同时接受 double 和 int 参数了。

如果你想在 Lambda 中实现相似的效果，那么你可以看看这部分内容 Lambda 继承

其他修饰符

我们在 Lambda 语法⼀节中简略介绍过这部分主题，但是你并不会被闭包类型调⽤操作符的默认声明所限制

到。

在 C++11 中，你可以添加 mutalbe 或者异常描述符。

如果可能的话，本书会使⽤⻓例⼦来⽤ const 标记闭包对象并且使 Lambda 为 noexcept。

你可以通过在参数声明后⾯那部分指定 mutable 或者 noexcept 来使⽤这些关键字。

auto myLambda = [](int a) mutable noexcept { /* do something */ };

编译器会展开为：

struct __anonymousLambda {

inline void operator()(int a) noexcept{ /* do something */ }

};

请注意，const 关键字此时会消失，并且调⽤操作符可以修改 Lambda 的成员变量了。

但是，成员变量呢？我们要如何在 Lambda 中声明成员变量？

请看下⼀个章节——关于「捕获」变量。

4. 捕获

C++ Lambda Story - From C++98 to C++20.md 1/1/2023

17 / 92

捕获⼦句-[] 操作符绝不仅仅只是 Lambda 的引入符号，同时它还兼顾捕获变量的列表的职能。

通过从 Lambda 表达式外部捕获变量，你可以在闭包类型中创建成员变量（非静态成员），然后，在 Lambda

函数体中，你就可以使⽤它了。

我们可以弄⼀个类似于 C++98/03 章节中 PrintFunctor 的内容，在这个类中，我们添加成员变量

std::string strText 并让他在构造函数中被初始化。

拥有⼀个成员变量可以让我们存储可调⽤对象的⼀些状态了。

⼀些有关捕获器的语法：

[&] - 引⽤捕获，⾃动捕获声明在捕获范围内的⽣命周期尚未结束的变量。

[=] - 值捕获（创建拷⻉），⾃动捕获声明在捕获范围内的⽣命周期尚未结束的变量。

[x, &y] - x 为值捕获，y 为显式引⽤捕获。

[args...] - 捕获⼀个模板参数包，全部都是值捕获

[&args...] - 捕获⼀个模板参数包，全部都是引⽤捕获

⼀些例⼦：

int x = 2, y = 3;

const auto l1 = []() {

return l1;

}; // 没有捕获

const auto l2 = [=]() {

return x;

}; // 值捕获（拷⻉）

const auto l3 = [&]() {

return y;

}; // 引⽤捕获

const auto l4 = [x]() {

return x;

}; // 仅值捕获x

const auto lx = [= x]() {

return x;

}; // 错误的语法，不需要=来对x显式进⾏拷⻉（值捕获）

const auto l5 = [&y]() {

return y;

}; // 仅引⽤捕获y

const auto l6 = [x, &y]() {

return x * y;

}; // 值捕获x，引⽤捕获y

const auto l7 = [=, &x]() {

return x + y;

}; // 全部都是值捕获，除了x是引⽤捕获

const auto l8 = [&, y]() {

return x - y;

}; // 全都是引⽤捕获，除了y是值捕获

为了理解在捕获变量的过程中发⽣了什么，让我们⼀起来思考下⾯这个例⼦：

C++ Lambda Story - From C++98 to C++20.md 1/1/2023

18 / 92

代码 2-5 捕获⼀个变量

std::string str{"Hello World"};

auto foo = [str]() {

std::cout << str << '\n';

};

foo();

上⾯这个 Lambda，str 被值捕获（构造了⼀个拷⻉）。

编译器将⾃动⽣成这样的仿函数：

代码 2-6 编译器可能⽣成的仿函数，单变量

class __unnamedLambda {

public:

inline /*constexpr */ void operator()() const {

std::operator<<(std::operator<<(std::cout, str), '\n');

}

private:

std::string str;

public:

__unnamedLambda(std::string _str) : str{_str} {}

};

如上述的展开代码，⼀个变量被传进构造函数中，在 Lambda 声明中被称为“就地”。

更准确的定义在 [expr.prim.lambda#21]：当解析 Lambda 表达式时，通过值捕获的实体将直接初始化在每个对

应⽣成的闭包对象中的非静态成员数据。

当然了，上述代码中的构造函数（__unnamedLambda）仅仅是⽤作演⽰和解释⽤途，编译器真正⽣成的内容会

与此有所差别，并且不会暴露给⽤户。

代码 2-7 引⽤捕获两个变量

int = 1, y = 1;

std::cout << x << " " << y << std::endl;

const auto foo = [&x, &y]() noexcept {

++x;

++y;

};

foo();

std::cout << x << " " << y << std::endl;

上述代码展开后，可能是：

C++ Lambda Story - From C++98 to C++20.md 1/1/2023

19 / 92

代码 2-8 编译器可能⽣成的仿函数，双变量，引⽤

class __unnamedLambda {

public:

inline /* constexpr */ void operator()() const noexcept {

++x;

++y;

}

private:

int& x;

int& y;

public:

__unnamedLambda(int& _x, int& _y) : x{_x}, y{_y} {}

};

由于我们是通过引⽤的⽅式捕获 x 和 y 的，所以闭包类型中的成员变量也是引⽤类型的。

请注意：值捕获变量的值是在 Lambda 定义时，⽽不是在使⽤时。但是引⽤捕获变量的内容是在

Lambda 使⽤时，⽽不是定义时。⼆者是有区别的。

虽然指定 [=] 或者 [&] 可能很⽅便，因为它会⾃动捕获仍在⽣命周期内的全部变量，但是，若能指明捕获的变

量是哪些，将会更加清晰明确。

这样编译器才能警告出哪些非预期的影响（参⻅全局变量和静态变量）。

当然，如果你想要了解更多更详细的内容，可以翻阅 Scott Meyers 所著的《Effective Modern C++》第 31 项

——“避免默认捕获模式”的内容。

请注意： C++ 闭包不会延⻓被捕获引⽤对象的剩余⽣命周期。请务必确保捕获对象在 Lambda 调⽤时

仍然“存活”。

mutable 关键字

通过闭包类型默认调⽤操作符获取的，都是带有 const 关键字限定的，你⽆法在 Lambda 表达式内部对他们做

出任何修改。

如果你希望进⾏修改的操作，那就需要在参数列表后添加 mutable 关键字。

它可以有效的去除闭包类型调⽤操作符中的 const 修饰符。举⼀个mutable 的简单例⼦：

int x =1;

auto foo =[x]() mutable { ++x; };

它会被展开为：

剩余91页未读，继续阅读

a的初始值为10^(-16) y = log((2exp(2)0.02585/(1-exp(1/0.02585(1.1-x)))+ 1.125(x-1.1))a(x-1.1)/(810^(-9)))这个是要建立的函数类型，只含有一个参数a，需要求解，下面是我的实际数据点 x = 0.1:0.1:5; y_data = [-17.07912228, -17.07912228, -16.8427335, -16.6890252, -16.66282283, -16.49643209, -16.46765313, -16.40577772, -16.36655701, -16.2865143, -16.16938895, -16.05982674, -16.04577499, -15.94414234, -15.84806851, -15.7569308, -15.67984072, -15.58160228, -15.51651566, -15.40269786, -15.32736814, -15.22405053, -15.14731673, -15.08847623, -15.01449582, -14.97228176, -14.86533268, -14.79500737, -14.74691493, -14.67235383, -14.60958366, -14.56946988, -14.47909894, -14.4316967, -14.3688958, -14.31803738, -14.26179766, -14.20855315, -14.15800087, -14.0899474, -14.02007772, -13.91533089, -13.80062195, -13.66709055, -13.45783611, -13.1198665, -12.61705293, -11.96705575, -11.22774652, -10.45513517]; y的实际数据点是取了对数的，而函数模型没有取对数，用c或c++用L-M法求解，L-M法需要设立误差函数，误差函数为F=0.5（f T *f）写出c语言代码并验证正确性和合理性

printf("LM failed to converge after %d iterations.\n", iter); return; } mu *= v; } } } printf("LM converged after %d iterations.\n", iter); } int main() { LM(a, x); printf("a = %lf\n", a[0]...

System.out.println("----------entrySet+lambda----------");

System.out.println("----------entrySet lambda----------"); 是一个用于输出一行字符串的语句。它会在控制台中打印出"----------entrySet lambda----------"。在这个例子中，它可能用于标记某个特定的代码块的开始...

lambda <- BoxCox.lambda(pep2) lambda new_ts <- BoxCox(pep2,lambda) new_ts BoxCox.lambda(new_ts) hist(new_ts, breaks = 100) max(new_ts)

- `BoxCox.lambda(pep2)`：使用Box-Cox变换估计数据的最佳lambda值 - `new_ts <- BoxCox(pep2,lambda)`：使用估计出的最佳lambda值对数据进行Box-Cox变换 - `BoxCox.lambda(new_ts)`：检查新数据的最佳lambda值是否...

在运行以下R代码时：# 画Beta1的Prediction error图 fit1 <- glmnet(X, y, alpha=0, lambda=lambda[which.min(mse1)]) y_pred1 <- as.vector(predict(fit1, newx=X)) pred_error1 <- mean((y - y_pred1)^2) lambda <- as.vector(lambda) pred_error1 <- as.vector(pred_error1) plot(lambda, as.vector(pred_error1), type="l", xlab="lambda", ylab="Prediction error", main="Beta1 Prediction error")。出现以下问题：Error in xy.coords(x, y, xlabel, ylabel, log) : 'x'和'y'的长度不一样。请合理修改原代码

根据代码，我们可以看到lambda向量和pred_error1都被转换为向量。因此，我们可以尝试检查它们的长度是否相等。可能出现的情况是，它们的长度不相等，导致绘图失败。修复此错误的一种方法是，确保lambda和pred_...

install.packages('glmnet') library(glmnet) graphics.off() rm(list =ls()) install.packages('readxl') library(readxl) data<-read_excel("C:\\Users\\cora\\Desktop\\吉林省上市\\data1.xlsx") data X=read_excel("C:\\Users\\cora\\Desktop\\吉林省上市\\zbl.xlsx") X x<-as.matrix(X) x Y=read.csv("C:\\Users\\cora\\Desktop\\吉林省上市\\ybl.xlsx") Y y<-as.matrix(Y) y X=scale(X,center = T,scale = T) colMeans(X) #求平均值 apply(X,2,sd) #标准差 #c()，把将值合并成向量或列表 #rep(0，p/2-5),把0重复p/2-5次 beta = c(0.15,-0.33,0.25,-0.25,0.05,rep(0,p/2-5), -0.25,0.12,-0.125,rep(0,p/2-3)) # %%矩阵乘法 y = x%%beta + rnorm(180,sd=0.5) # rnorm(n, mean = 0, sd = 1) # n 为产生随机值个数（长度），mean 是平均数， sd 是标准差 y = scale(y) lambda<-0.01 #lasso la.eq <- glmnet(x,y,intercept = F,alpha=1) plot(la.eq,xvar ="lambda",label = F,lwd=2) mod_cv <- cv.glmnet(x=x,y=y,intercept = F,alpha=1) plot(mod_cv) print(paste(mod_cv$lambda.min, log(mod_cv$lambda.min))) print(paste(mod_cv$lambda.lse, log(mod_cv$lambda.lse))) best_lambda<-mod_cv$lambda.min best_lambda best_model<- glmnet(X,y,alpha =1,lambda = best_lambda) coef(best_model)

20. `plot(mod_cv)`: 这个函数用于绘制交叉验证结果的图形。 21. `print(paste(mod_cv$lambda.min, log(mod_cv$lambda.min)))`: 这行代码打印最小的正则化参数及其对数值。 22. `print(paste(mod_cv$lambda.lse, ...

请在以下R代码基础上：# ①建立50×30的随机数据和30个变量 set.seed(123) X <- matrix(rnorm(50*30), ncol=30) y <- rnorm(50) # ②生成三组不同系数的线性模型 beta1 <- rnorm(30, mean=1, sd=0.5) beta2 <- rnorm(30, mean=2, sd=0.5) beta3 <- rnorm(30, mean=3, sd=0.5) # 定义一个函数用于计算线性回归的CV值 cv_linear <- function(X, y, k=10, lambda=NULL) { n <- nrow(X) if (is.null(lambda)) { lambda <- seq(0, 1, length.out=100) } mse <- rep(0, length(lambda)) folds <- sample(rep(1:k, length.out=n)) for (i in 1:k) { X_train <- X[folds!=i, ] y_train <- y[folds!=i] X_test <- X[folds==i, ] y_test <- y[folds==i] for (j in 1:length(lambda)) { fit <- glmnet(X_train, y_train, alpha=0, lambda=lambda[j]) y_pred <- predict(fit, newx=X_test) mse[j] <- mse[j] + mean((y_test - y_pred)^2) } } mse <- mse / k return(mse) } # ③（线性回归中）分别计算这三组的CV值 lambda <- seq(0, 1, length.out=100) mse1 <- cv_linear(X, y, lambda=lambda) mse2 <- cv_linear(X, y, lambda=lambda) mse3 <- cv_linear(X, y, lambda=lambda) # ④（岭回归中）分别画出这三组的两张图，每组两张图均以lambda为横坐标： library(glmnet) par(mfrow=c(2,3)) # 画Beta1的CV error图 plot(lambda, mse1, type="l", xlab="lambda", ylab="CV error", main="Beta1 CV error") # 画Beta1的Prediction error图 fit1 <- glmnet(X, y, alpha=0, lambda=lambda[which.min(mse1)]) y_pred1 <- as.vector(predict(fit1, newx=X)) pred_error1 <- mean((y - y_pred1)^2) lambda <- as.vector(lambda) pred_error1 <- as.vector(pred_error1) if (length(lambda) != length(pred_error1)) { if (length(lambda) > length(pred_error1)) { pred_error1 <- rep(pred_error1, length.out = length(lambda)) } else { lambda <- rep(lambda, length.out = length(pred_error1)) } } plot(lambda, pred_error1, type="l", xlab="lambda", ylab="Prediction error", main="Beta1 Prediction error") # 画Beta2的CV error图 plot(lambda, mse2, type="l", xlab="lambda", ylab="CV error", main="Beta2 CV error") # 画Beta2的Prediction error图 fit2 <- glmnet(X, y, alpha=0, lambda=lambda[which.min(mse2)]) y_pred2 <- predict(fit2, newx=X) pred_error2 <- mean((y - y_pred2)^2) plot(lambda, pred_error2, type="l", xlab="lambda", ylab="Prediction error", main="Beta2 Prediction error") # 画Beta3的CV error图 plot(lambda, mse3, type="l", xlab="lambda", ylab="CV error", main="Beta3 CV error") # 画Beta3的Prediction error图 fit3 <- glmnet(X, y, alpha=0, lambda=lambda[which.min(mse3)]) y_pred3 <- predict(fit3, newx=X) pred_error3 <- mean((y - y_pred3)^2) plot(lambda, pred_error3, type="l", xlab="lambda", ylab="Prediction error", main="Beta3 Prediction error")。对每组数据绘制纵坐标为Prediction error的图的代码进行修改

plot(lambda, mse1, type="l", xlab="lambda", ylab="CV error", main="Beta1 CV error") # 画Beta1的Prediction error图 fit1 <- glmnet(X, y, alpha=0, lambda=lambda[which.min(mse1)]) y_pred1 <- as.vector...

粉丝: 1792
资源: 416

上传资源快速赚钱

我的内容管理收起

我的资源快来上传第一个资源

我的收益

登录查看自己的收益

我的积分登录查看自己的积分

我的C币登录后查看C币余额

我的收藏

我的下载

下载帮助

会员权益专享

现代C特性：Lambda表达式详解 - C 98至C 20.pdf

评论0

会员权益专享

最新资源

现代C特性：Lambda表达式详解 - C 98至C 20.pdf

评论0

C++ Lambda Story

PyPI 官网下载 | cdk-lambda-extensions-0.1.232.tar.gz

C++之Lambda研究.pdf

System.out.println("----------entrySet+lambda----------");

lambda <- BoxCox.lambda(pep2) lambda new_ts <- BoxCox(pep2,lambda) new_ts BoxCox.lambda(new_ts) hist(new_ts, breaks = 100) max(new_ts)

java课程设计单词簿

lambda 表达式--匿名函数

编码 pre-lambda post-lambda

lambda表达式->

c++ lambda表达式的类型

[Warning] lambda expressions only available with -std=c++11 or -std=gnu++11

beta2 = (2 * pi)./lambda.^2 .* (n + lambda .* diff(n)./diff(lambda)).^2;是什么意思

c++的lambda表达式捕获this_c++11

C++中lambda函数

谈谈C++lambda表达式

pagel.lambda函数

会员权益专享

最新资源