小编coi*_*oin的帖子

我正在阅读B. Stroustrup的关于C++ 17的思考合同,并协助一个小小的演讲,谈论他们,但我不确定我是否真的理解它们.

所以我有一些问题,如果有可能用一些例子来说明它们:

• 合同是否是经典的更好替代品,assert()它们应该一起使用吗？对于软件开发人员来说,简单的合同是什么？

• 合同会对我们处理异常的方式产生影响吗？如果是,我们应该如何使用例外和合同？

• 使用合同是否意味着执行时的开销？我们是否允许在发布代码上停用它们？

从提案N4415编辑:

可以编写Vector类的索引操作符的前置条件合约:
T& operator[](size_t i) [[expects: i < size()]];

类似地,ArrayView类的构造函数上的条件后约定可表示为: ArrayView(const vector<T>& v) [[ensures: data() == v.data()]];

使用Clang 3.5,3.6或3.7,带有std=c++1y以下代码的标志不能编译:

#include <iostream>
auto foo(auto bar) { return bar; }
int main() {
  std::cout << foo(5.0f) << std::endl;
}

给出的错误是:

错误:函数原型中不允许'auto'

我使用g ++ 4.9没有错误.是否因为Clang尚未实现此功能而产生此错误,还是因为我不被允许这样做而且GCC以某种方式允许它？

我在下面用一个简单的代码复制了我遗漏的东西.
B类拥有A类作为成员并使用相同的类型名称.
我想避免复制这些模板,以便在main()中我可以调用类似B b(a,3.0)的东西来重用A中的模板.这可能吗？

#include <iostream>
#include <vector>

template<int N, typename T=double>
struct A
{
    A(T val) : vecA(N, val) {}
    void print() { for (auto i : vecA) std::cout << i << ";"; }
    std::vector<T> vecA;
};

template<int N, typename T>
struct B
{
    B(const A<N,T> & in, T scal) : a(in), scalB(scal) {}
    void print() { a.print(); std::cout << " | " << scalB << std::endl; }
    A<N,T> a;
    T scalB;
};


int main()
{
    A<5,float> …

我尝试A为我的非成员serialize()函数提供类的getter,因为从成员访问是私有的.

template<typename T>
class A
{
public:
  A(const T& id) : m_id(id) {}
  T& getRef() { return m_id; } // not giving good results
  T  getId()  { return m_id; } // not giving good results
  const T& getRef() const { return m_id; } // not giving good results
private: // I would like to keep it private
  T m_id;
}

namespace boost { namespace serialization {

template<class Archive,typename T>
void serialize(Archive &ar, A &a, const unsigned …

我使用了下面的代码,它适用于使用printContainer()打印一个简单的std :: vector .
我现在想要使用printContainerV2()扩展它的嵌套容器
我已经尝试使用模板来确定该类型是否是一个stl容器,但它似乎不是这样做的方式.

#include <iostream>
#include <iterator>
#include <vector>

template <typename Iter, typename Cont>
bool isLast(Iter iter, const Cont& cont)
{
    return (iter != cont.end()) && (next(iter) == cont.end());
}


template <typename T>
struct is_cont {
    static const bool value = false;
};

template <typename T,typename Alloc>
struct is_cont<std::vector<T,Alloc> > {
    static const bool value = true;
};


template <typename T>
std::string printContainer(T const& container)
{
    std::string str = "{";
    for (auto it …

所以我有很多我想用Symfony序列化程序序列化的类.例如

class Foo
{
  public $apple = 1;
  public $pear = null;

  public function serialize() {
    Utils::serialize($this);
  }
}

我通过以下serialize()调用序列化:

class Utils {
    public static function serialize($object) {
      $encoder = new XmlEncoder();
      $normalizer = new ObjectNormalizer();
      $serializer = new Serializer(array($normalizer), array($encoder));
      $str = $serializer->serialize($object, 'xml')
    }
}

产生的输出给了我:

<apple>1</apple><pear/>

预期的输出应为:

<apple>1</apple>

我看了一下Symfony 2.8 doc,并设法通过使用找到了一个快速的解决方案$normalizer->setIgnoredAttributes("pear").

所以改进的序列化静态函数看起来像这样

class Utils {
  public static function ignoreNullAttributes($object) {
    $ignored_attributes = array();
    foreach($object as $member => $value) {
      if (is_null($object->$member)) …

我正在研究N维网格.
我想根据任何维度(2D,3D,4D等)生成嵌套循环.
我怎么能以优雅和快速的方式做到这一点？下面简单说明我的问题.我用C++编写,但我认为这类问题对其他语言有用.
我需要知道我做的东西部分中的索引(i,j,k ......).编辑:lower_bound和upper_bound表示网格中的索引,因此它们始终为正数.

#include <vector>

int main()
{
    // Dimension here is 3D
    std::vector<size_t> lower_bound({4,2,1});
    std::vector<size_t> upper_bound({16,47,9});

    for (size_t i = lower_bound[0]; i < upper_bound[0]; i ++)
        for (size_t j = lower_bound[1]; j < upper_bound[1]; j ++)
            for (size_t k = lower_bound[2]; k < upper_bound[2]; k ++)
                // for (size_t l = lower_bound[3]; l < upper_bound[3]; l ++)
                //  ...
                {
                    // Do stuff such as
                    grid({i,j,k}) = 2 * i + 3 *j - 4 * k; …

我想用a unordered_map<std::pair<enum_class,other_enum_class>,std::uint8_t>来管理一些像素图格式.

这里的最小代码:

#include <unordered_map>
#include <utility>
#include <cstdint> 
#include <iostream>
#include <functional>

enum class PNM : std::uint8_t { PBM, PGM, PPM };
enum class Format : bool      { BIN, ASCII };

struct pair_hash {
public:
    template <typename T, typename U>
    std::size_t operator()(const std::pair<T, U> &x) const { 
        return std::hash<T>()(x.first) ^ std::hash<U>()(x.second); 
    }
};

int main(){

    std::unordered_map<std::pair<PNM, Format>, std::uint8_t, pair_hash> k_magic_number ({
        { { PNM::PBM, Format::BIN   }, 1 }, { { PNM::PGM, Format::BIN   }, 2 }, { { PNM::PPM, …

我想计算红色圆圈半径(图2).我在使用OpenCV的HoughCircles找到这些圈子时遇到了麻烦.正如你在图中看到的那样.2我只能在中心找到使用HoughCircles以黑色显示的小圆圈.

原版的 图2.

因为我知道红色圆圈的中心(与红色圆圈的中心相同),有没有办法简单地计算红色圆圈的半径？

是否也可以在更复杂的图像上使用通用的方法计算圆的半径,例如:

编辑:在获得图2后,我的代码中有趣的部分:

threshold(maskedImage, maskedImage, thresh, 255, THRESH_BINARY_INV | THRESH_OTSU);
    std::vector<Vec3f> circles;
// Canny(maskedImage, maskedImage, thresh, thresh * 2, 3);

HoughCircles(maskedImage, circles, CV_HOUGH_GRADIENT, 1, src_gray.rows / 4, cannyThreshold, accumulatorThreshold, 0, 0);

Mat display = src_display.clone();
for (size_t i = 0; i < circles.size(); i++)
{
    Point center(cvRound(circles[i][0]), cvRound(circles[i][1]));
    int radius = cvRound(circles[i][2]);
    // circle center
    circle(display, center, 3, Scalar(0, 255, 0), -1, 8, 0);
    // circle outline
    circle(display, center, radius, Scalar(0, 0, 255), 3, 8, 0);
} …

给出两个std :: vector v1,v2.
我想知道使用std :: swap(v1,v2)比v1.swap(v2)有什么好处.

关于性能观点,我已经实现了一个简单的测试代码(我不确定它是否相关):

#include <iostream>
#include <vector>
#include <random>
#include <chrono>
#include <algorithm>

#define N 100000

template<typename TimeT = std::chrono::microseconds>
struct Timer
{
    template<typename F, typename ...Args>
    static typename TimeT::rep exec(F func, Args&&... args)
    {
        auto start = std::chrono::steady_clock::now();
        func(std::forward<Args>(args)...);
        auto duration = std::chrono::duration_cast<TimeT>(std::chrono::steady_clock::now() - start);
        return duration.count();
    }
};

void test_std_swap(std::vector<double>& v1, std::vector<double>& v2)
{
    for (int i = 0; i < N; i ++)
    {
        std::swap(v1,v2);
        std::swap(v2,v1);
    }
}

void test_swap_vector(std::vector<double>& v1, std::vector<double>& …