小编Vin*_*ent的帖子

我的目标是通过CMake链接库/usr/lib/libboinc_api.a和/usr/lib/libboinc.a.所以我使用不同FIND_XXXX模块中给出的示例,我尝试:

    FIND_LIBRARY(BOINC_LIBRARY NAMES libboinc_api libboinc
             DOC "The Boinc libraries")
    MESSAGE(${BOINC_LIBRARY})

但是CMake没有找到任何东西.

所以我尝试(使用扩展名):

    FIND_LIBRARY(BOINC_LIBRARY NAMES libboinc_api.a libboinc.a
             DOC "The Boinc libraries")
    MESSAGE(${BOINC_LIBRARY})

并且消息给了我/usr/lib/libboinc_api.a.

所以我的问题是:

1)为什么我被迫精确扩展(在cmake FIND模块中,没有精确的扩展)以及如何避免这种情况？

2)如何链接这两个文件？(在目前的情况下,消息说只找到第一个,但也许我误解了......)

非常感谢你.

我有一个问题与下面的代码(这是一个非常简单的例子,重现我的程序中的错误):

#include <iostream>

using namespace std;

template<class T> class CBase
{
    public:
        template <class T2> CBase(const T2 &x) : _var(x) {;}
        template <class T2> CBase (const CBase<T2> &x) {_var = x.var();}
        ~CBase() {;}
        T var() const {return _var;}
    protected:
        T _var;
};

template<class T> class CDerived : public CBase<T>
{
    public:
        template <class T2> CDerived(const T2 &x) : CBase<T>(x) {;}
        template <class T2> CDerived (const CBase<T2> &x) : CBase<T>(x) {;}
        ~CDerived() {;}
};

int main()
{
    CBase<double> bd(3);
    CBase<int> bi(bd); …

我正在创建一个类,它是一种容器,我想创建一个构造函数,可以采用像std :: vector和其他标准容器这样的"第一个"和"最后一个"迭代器.什么是正确的语法？(我想要一个模板,一个可以使用任何第一个/最后一个迭代器类型的函数(比如我认为的标准库).非常感谢!

举个例子,我想要这样的东西:

template<class ...> MyClass(... first, ... last) 

但是......是什么？

非常感谢你.

关于第一个答案:我想要一个特定的构造函数,它将迭代器作为参数(因为我已经有了将值和指针作为参数的构造函数)

编辑:这样的话好吗？

template<class T1, class T2> MyClass(std::iterator<T1, T2> first, std::iterator<T1, T2> last)

考虑一个"正常"的实数,TREAL x在C++(不低于正常,而不是为NaN /无限)(TREAL= float,double,long double)
是很好的解决方案下面找到一个和下一个x从一个浮点点？

TREAL xprev = (((TREAL)(1.)) - std::numeric_limits<TREAL>::epsilon()) * x;
TREAL xnext = (((TREAL)(1.)) + std::numeric_limits<TREAL>::epsilon()) * x;

非常感谢你.

请考虑以下代码:

template<typename T> class Base
{
    Base();
    Base(const Base<T>& rhs);
    template<typename T0> explicit Base(const Base<T0>&  rhs);
    template<typename T0, class = typename std::enable_if<std::is_fundamental<T0>::value>::type> Base(const T0& rhs);
    explicit Base(const std::string& rhs);
};

template<typename T> class Derived : Base<T>
{
    Derived();
    Derived(const Derived<T>& rhs);
    template<class T0> Derived(const T0& rhs) : Base(rhs); 
    // Is there a way to "inherit" the explicit property ?
    // Derived(double) will call an implicit constructor of Base
    // Derived(std::string) will call an explicit constructor of Base
};

有没有办法以这样的方式重新设计此代码,Derived …

以下代码总结了我的问题:

template<class Parameter>
class Base {};

template<class Parameter1, class Parameter2, class Parameter>
class Derived1 : public Base<Parameter>
{ };

template<class Parameter1, class Parameter2, class Parameter>
class Derived2 : public Base<Parameter>
{
public :
    // Copy constructor
    Derived2(const Derived2& x);

    // An EXPLICIT constructor that does a special conversion for a Derived2
    // with other template parameters
    template<class OtherParameter1, class OtherParameter2, class OtherParameter>
    explicit Derived2(
        const Derived2<OtherParameter1, OtherParameter2, OtherParameter>& x
    );

    // Now the problem : I want an IMPLICIT constructor …

对于GPL计划,我们可以在程序开头添加一个小小的通知:(http://www.gnu.org/licenses/gpl-3.0.en.html)

<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year>  <name of author>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY …

如何在标准C++/C++ 11(无POSIX函数)中优化std :: ifstream和std :: ofstream的读写速度？(1 < - 因为有几个问题,这些数字标识不同的点)

我不确切知道缓冲区的作用,所以你可以确认:

• 用于读取:文件的大部分被预加载到内存中(因此缓冲区大小定义了这个大部分的大小)(2)
• 写入:数据写入内存,一旦缓冲区已满,就会从内存传输到文件系统(3)

如何在std :: ifstream和std :: ofstream上设置缓冲区大小？(4)

考虑到我使用非常大的二进制文件(几个10 GB),并且文件系统通常是大型读/写的最佳选择,我可以定义100 MB的缓冲区大小吗？如果它会降低性能,为什么？(5)

最后,默认缓冲区是"智能",因为ifstream/ofstream将检测您正在读取/写入文件的数据量并调整缓冲区大小以提供最大速度？(6)

考虑:

double data; 
double array[10]; 
std::vector<int> vec(4, 100); 
MyClass myclass;   

是否有区别:

sizeof(double);
sizeof(double[10]);
sizeof(std::vector<int>);
sizeof(MyClass);

和

sizeof(data);
sizeof(array);
sizeof(vec);
sizeof(myclass);

这两种语法是不同的还是严格等同的？是否所有这些都在编译时进行评估？如果没有,在运行时评估哪一个？

我有一个为许多类型重载的函数.但我目前的问题是由于(LWS在这里:lws):

#include <iostream>
#include <string>
#include <sstream>
#include <type_traits>

// First version
template<typename T, class = typename std::enable_if<std::is_fundamental<T>::value>::type> 
std::string f(const T& x)
{
    return std::to_string(x);
}

// Second version
template<typename... T> 
std::string f(const std::tuple<T...>& x)
{
    return std::to_string(sizeof...(T)); // It's just an example here
}

// Third version
template<typename T, class = typename std::enable_if<!std::is_fundamental<T>::value>::type, class = void> 
std::string f(const T& x)
{
    std::ostringstream oss;
    oss<<x;
    return oss.str();
}

// Main
int main(int argc, char* argv[])
{
   std::cout<<f(42)<<std::endl;
   std::cout<<f(std::string("Hello …