相关疑难解决方法(0)

#include <initializer_list>

struct Obj {
    int i;
};

Obj a, b;

int main() {
    for(Obj& obj : {a, b}) {
        obj.i = 123;   
    }
}

该代码无法编译，因为来自的值initializer_list {a, b}被当作const Obj&，并且不能绑定到非const引用obj。

是否有一种简单的方法可以使类似的构造工作，即遍历像like a和bhere 这样的不同变量中的值。

我一直在做基本程序来找到矢量的最大值,最小值,中值,方差,模式等.一切都很顺利,直到我进入模式.

我看到它的方式,我应该能够循环遍历向量,对于每个出现的数字,我在地图上增加一个键.找到具有最高值的密钥将是发生最多的密钥.与其他键相比,它会告诉我它是单个多重模式还是无模式答案.

这是导致我如此麻烦的代码块.

map<int,unsigned> frequencyCount;
// This is my attempt to increment the values
// of the map everytime one of the same numebers 
for(size_t i = 0; i < v.size(); ++i)
    frequencyCount[v[i]]++;

unsigned currentMax = 0;
unsigned checked = 0;
unsigned maax = 0;
for(auto it = frequencyCount.cbegin(); it != frequencyCount.cend(); ++it )
    //checked = it->second;
    if (it ->second > currentMax)
    {
        maax = it->first;
    }
    //if(it ->second > currentMax){
    //v = it->first

cout << " The highest value …

关于这个问题的评论可以使用C++ 11来auto提高性能吗？获得了很多选票,并暗示"让它不太可能无意中感到悲观"作为答案.我以前从未注意过这个词.我想这与优化相反.

任何人都可以给出更详细的定义吗？在编程环境中它意味着什么？如何使代码看起来像悲观？

从C++ 11开始,我们可以使用auto a = 1+2而不是int a = 1+2编译器,并且编译器会a自行推断出类型.它是如何工作的？编译时(更多操作)比自己声明类型更慢吗？

我使用auto得到了不同的结果,并Vector在求和两个向量时使用.

我的代码:

#include "stdafx.h"
#include <iostream>
#include "D:\externals\eigen_3_1_2\include\Eigen\Geometry"

typedef Eigen::Matrix<double, 3, 1>       Vector3;

void foo(const Vector3& Ha, volatile int j) 
{
    const auto resAuto = Ha + Vector3(0.,0.,j * 2.567);
    const Vector3 resVector3 = Ha + Vector3(0.,0.,j * 2.567);

    std::cout << "resAuto = " << resAuto <<std::endl;
    std::cout << "resVector3 = " << resVector3 <<std::endl;
}

int main(int argc, _TCHAR* argv[])
{
    Vector3 Ha(-24.9536,-29.3876,65.801);
    Vector3 z(0.,0.,2.567);

    int j = 7;

    foo(Ha,j);
    return 0;
}

结果:

resAuto = -24.9536,-29.3876,65.801 …

为牛顿法编写一个实现雅可比矩阵的函数，我注意到一个非常严重的错误。

调用函数

auto DF = [T](VectorXd y){
    return PhiAndW(y(0),y(1),T).second - MatrixXd::Identity(2,2);
 };

只返回 的值PhiAndW(y(0),y(1),T).second并省略 的减法MatrixXd::Identity(2,2)。但是如果我将代码更改为

auto DF = [T](VectorXd y){
    MatrixXd mat = PhiAndW(y(0),y(1),T).second - MatrixXd::Identity(2,2);
    return mat;
 };

一切顺利。

我试图重现它，这不是完全相同的行为，但它的行为也不如预期：

考虑以下代码：

MatrixXd FF(MatrixXd y){
  return y;
}

int other(){

  auto DF = [](MatrixXd y){
    MatrixXd test = FF(y)  - MatrixXd::Identity(2,2);
    return test;
  };

  std::cout << DF(MatrixXd::Ones(2,2)) <<std::endl;
  std::cout << std::endl;
  std::cout << (MatrixXd::Ones(2,2) - MatrixXd::Identity(2,2))<< std::endl;

}

它会打印

>  1 0
>  0 1 
> …

这个问题与现有问题“使用 C++11 的‘自动’能否提高性能？ ”相反。

该问题的一个答案表明，使用auto不仅会产生积极的影响，还会产生消极的影响。

我相信我们需要一个单独的问题，答案集中在auto.