小编And*_*rey的帖子

我想知道为什么cbegin并cend在C++ 11中引入？

什么情况下使用这些方法时,使得从常量重载的差异begin和end？

编译下面的代码时,我在VC2010中遇到错误C2078.

struct A
  {
  int foo;
  double bar;
  };

std::array<A, 2> a1 = 
  // error C2078: too many initializers
  {
    {0, 0.1},
    {2, 3.4}
  };

// OK
std::array<double, 2> a2 = {0.1, 2.3};

我发现正确的语法a1是

std::array<A, 2> a1 = 
  {{
    {0, 0.1},
    {2, 3.4}
  }};

问题是:为什么需要额外的括号a1但不是必需的a2？

更新

这个问题似乎并不特定于std :: array.一些例子:

struct B
  {
  int foo[2];
  };

// OK
B meow1 = {1,2};
B bark1 = {{1,2}};

struct C
  {
  struct 
    { 
    int a, b; 
    } …

让我们考虑一个用C++ 11编写的模板函数,它迭代一个容器.请排除考虑范围循环语法,因为我正在使用的编译器尚不支持它.

template <typename Container>
void DoSomething(const Container& i_container)
  {
  // Option #1
  for (auto it = std::begin(i_container); it != std::end(i_container); ++it)
    {
    // do something with *it
    }

  // Option #2
  std::for_each(std::begin(i_container), std::end(i_container), 
    [] (typename Container::const_reference element)
    {
    // do something with element
    });
  }

什么是for loop vs的优缺点std::for_each:

一场表演？(我不希望有任何区别)

b)可读性和可维护性？

在这里,我看到了许多缺点for_each.循环会不会接受c风格的数组.lambda形式参数的声明是如此冗长,不可能在auto那里使用.不可能突破for_each.

在C++之前的11天里,反对for是需要为迭代器指定类型(不再容纳)以及很容易错误地输入循环条件(我从未在10年内做过这样的错误).

作为结论,我for_each的观点与普遍观点相矛盾.我在这里错过了什么？

我想写一个模板函数,它接受2个值和一个函子或一个lambda.该函数使用这些值调用仿函数并返回结果.

template <typename T, typename Fn> 
_ReturnTypeOfPred_ Apply(T x, T y, Fn fn)
  {
  return fn(x, y);
  }

问题:如何定义返回类型Apply等于返回类型Fn？它不一定等于T,在这个仿函数的例子中

template <typename T> 
auto Sum(T x, T y) -> decltype(x+y)
  {
  return x+y;
  }

更新

第一个例子过于简单了.这个应该有用吗？

template <typename TContainer, typename Fn> 
auto Apply(const TContainer& x, const TContainer& y, Fn fn) -> decltype(fn(x.front(), y.front()))
  {
  return fn(x.front(), y.front());
  }

如果我在返回类型中重复return表达式,它会一直有效decltype吗？有更优雅的方式吗？

这个问题是如何推断出仿函数的返回值类型的后续行动？ 我正在以更抽象的方式重新制定它.

给定模板函数的伪代码

template <typename Arg, typename Fn>
auto ComputeSomething(Arg arg, Fn fn) -> decltype(<decl-expr>)
{
// do something
// ............
return fn(<ret-expr>)
}

where <ret-expr>是一个涉及的任意表达式,arg我将使用什么<decl-expr>来设置返回类型ComputeSomething等于函子的返回类型.

仿函数可以是类,lambda或函数指针.

到目前为止我发现的部分解决方案.

(a)ecatmur所做的相关问题的答案.从本质上讲,它重复了返回语句<decl-expr>.问题:它容易出错,如果包含局部变量则无法工作.

(b)它仅适用于函数指针

template <typename Arg, typename Ret>
Ret ComputeSomething(Arg arg, Ret(*fn)(Arg))

(c)它假定仿函数的参数是类型的Arg(一般可能不成立)并且需要Arg默认构造

template <typename Arg, typename Fn>
auto ComputeSomething(Arg arg, Fn fn) -> decltype(fn(Arg())

(d)使用std::declval哪个应该解除默认构造限制,如在模板中推导函数的返回类型所建议的那样.谁有人解释它是如何工作的？

template <typename Arg, typename Fn>
auto ComputeSomething(Arg …

你能解释为什么下面的代码不能编译吗？一个明显的解决方法是添加一个1参数的重载Apply,是否有一个更简单的？

template <typename T>
T Identity(const T& i_val)
  {
  return i_val;
  }

template <typename Val, typename Fn>
Val Apply(const Val& v, Fn fn = Identity<Val>)
  {
  return fn(v);
  }

int main() {
  Apply(42);              // error: no matching function for call to 'Apply(int)'
  Apply(42, Identity<int>); // OK
  return 0;
}

让我们考虑以下代码片段

void Test()
  {
  int x = 0;

  int& rx = x;
  int* px = &x;

  auto apx = px;    // deduced type is int*
  auto arx = rx;    // deduced type is int
  }

人们可以从指针类型中得出类比,期望推导出的类型arx是int&,但int事实上.

标准中的规则是什么？它背后的原因是什么？有时我会被这样的情况抓住:

const BigClass& GetBigClass();
...
auto ref_bigclass = GetBigClass();   // unexpected copy is performed

从Visual Studio DLL调用ITK时内存泄漏的后续问题

我把问题提炼到最简单的例子.

struct A
  {
  public:
    A()
      {
      mp_data = new int(0x42);
      }
    ~A()
      {
      delete mp_data;
      }
    int* mp_data;
  };

A a;

在DLL中定义此类全局类时,Visual Studio调试CRT报告在应用程序关闭时泄漏mp_data.除了禁用泄漏报告外,有没有人知道解决方法？

新程序员在这里.像超级新人.我正在为我爸爸的生日写一个程序.

#include <stdio.h>
#include <time.h>

int main()
{
    int CurrentTime;
    system("start https://www.youtube.com/watch?v=FchMuPQOBwA");
    return 0;
}

到目前为止,我有这个.我怎么做才能让他在生日或特定时间之前无法打开它？在time.h中查看并搜索了一下,但我似乎无法找到解决方案.另外我如何将它发送给他所以它只是一个.exe而且他看不到代码？

提前致谢

我需要一个bash脚本来将所有图像保存在指定的文件夹中；采取分辨率，如果分辨率低于最小值，则不执行任何操作，否则请创建中等拇指图像（200x150像素）。

我在Windows中使用Imagemagick。但是在Linux上，我不能使用相同的脚本，因此需要编写一个新脚本。

到目前为止，这就是我提出的。

#!/bin/bash
for files in /path/to/image/*
  do
       TESTFILE=`echo "$files" | sed 's/|/ /g' | xargs file -b | awk '{print $1}'`
       while read F
       CHECKSIZE=`file "$TESTFILE" -b | sed 's/ //g' | sed 's/,/ /g' | awk  '{print $2}' | sed 's/x/ /g' | awk '{print $1}'`
     if [ $CHECKSIZE -ge  200  ]; then
        convert -sample 200x150 "$F" "$F{_thumb}"
     fi
    done
  done

但是，当我运行此脚本时，它没有给我缩略图也没有给我任何错误。我对这些脚本非常陌生。

更新：

我想出了这个脚本，谢谢大家。但是现在我需要一个帮助。现在我想将新图像存储在图像文件夹内的文件夹中。例如，/ home / image是所有文件所在的位置。我希望将拇指图像存储在/ home / image / thumbs中。我也想将文件重命名为filename_thumb.jpg …

一个简单的C++问题:是否可以根据指针的运行时类型调用函数或其他函数？

例如,我有一个A类,B类是A的孩子.

我想写一个函数f

f(A* a)
{//do something
}
f(B* b)
{//do something else
}

//call f()
A* a = new A();
A* b = new B();
f(a);//do something
f(b);//do something, but I'd like it to "do something else"

额外的精度:A和B是从我的代码中定义和实例化的,所以我不能在A和B上使用常规的多态与虚函数...

我知道你可以使用一些RTTI,但有更优雅的解决方案吗？