小编SPM*_*PMP的帖子

我正在尝试在CMake项目上应用链接时间优化和LLVM,这将创建一个共享库.我的问题几乎和这个问题一样:

使用CMake在GCC和Clang/LLVM之间切换.

但是,答案似乎不再适用,因为llvm-ld新版本中不存在.在命令行上,我运行以下命令来获取LTO(假设只有2个.cpp文件):

编译为字节代码:

clang++ -c FirstClass.cpp -O3 -flto -o FirstClass.bc
clang++ -c SecondClass.cpp -O3 -flto -o SecondClass.bc

链接字节码:

llvm-link FirstClass.bc SecondClass.bc -o unoptimized.bc

优化字节码:

opt -O3 unoptimized.bc -o optimized.bc

将字节代码转换为共享对象:

clang++ -shared optimized.bc -o libTest.so

有人可以告诉我如何让CMake运行其他步骤吗？

我有一个私有继承的类std::string,并添加了一些函数.我希望能够像使用这个类一样std::string,所以我试图定义一个隐式转换运算符(operator string()).但是,我一直在收到inaccessible base错误.

#include <iostream>
#include <string>

using namespace std;
class Test:private string {
    int _a;
    public:
    operator string() {
        return "hello";
    }
};

int main() {
    Test t;
    if(t == "hello") {
        cout<<"world\n";
    }
}

错误:

trial.cpp: In function ‘int main()’:
trial.cpp:15:13: error: ‘std::basic_string<char>’ is an inaccessible base of ‘Test’
 if(t == "hello") {
         ^

问题:

1. 定义这样的转换是不是一个坏主意？这会破坏任何推荐的编程实践吗？
2. 我怎样才能做到这一点？

编辑:Clang更有帮助

trial.cpp:8:5: warning: conversion function converting 'Test' to its base class 'std::basic_string<char>' will …

我想知道是否有可能使用自动返回类型推导功能编写Python函数映射的C++等价物.我的想法是这样的:

vector<int> input({1,2,3});
auto output=apply(input,[](int num){return num*num;});

//output should be a vector {1,4,9}

我知道std::transform,但在目前的情况下,编写一个范围循环似乎更容易.

我希望我的代码中的块之前和之后都有空行。Astyle 支持这一点（Break-Blocks）。有没有办法用 clang-format 来做到这一点？我已经知道了KeepEmptyLinesAtTheStartOfBlocks，但如果我理解正确的话，那只会保留现有的空行。

请原谅我对这个话题不够清晰.我正在尝试创建用于将大类插入向量的函数.在这个例子中,我使用int的向量作为大类.

#include <vector>
#include <iostream>
using namespace std;

vector<vector<int>> vectorOfVectors;

void fn(const vector<int> &v) {
    vectorOfVectors.push_back(v);

}
void fn(vector<int> &&v) {
    vectorOfVectors.push_back(std::move(v));
}

int main() {
    vector<int> a({1});
    const vector<int> b({2});
    fn(std::move(a));
    fn(b);
    cout<<b[0];
}

显然,我希望在可能的情况下不要进行复制.我的问题:

1. 这段代码做得对吗？
2. 有没有更好的方法呢？
3. 对于使用自定义类的相同方法,我是否需要定义移动构造函数？

我正在尝试为特定类编写自定义分配器。我对分配器的经验基本上没有，所以这可能很明显。

我希望我的分配取决于某些参数。粗略地说，我希望有多个内存管理器，每个管理器管理几个对象。创建对象时，我将知道该对象应该属于哪个管理器。在阅读了大量关于重载的内容后operator new，我不知道如何实现我需要的东西。

这个页面说有一个版本operator new可以接受用户定义的参数，但似乎在使用new. 有人能指出如何构造除全局分配器以外的任何东西吗？在相关说明中，如果我使用重载的类特定的，如何调用参数化构造函数operator new？

我对模板编程有些新意,所以这可能是一个愚蠢的问题.我试图使用可变参数模板来检查一个类是否有一个成员(被调用member).为此,我写了这门课 has_member.

#include <iostream>
using namespace std;

class ClassWithMember
{
    public:
    int member;
};
class ClassWithoutMember
{
};

template <typename T>
class has_member
{
    template <typename... C>
    class tester: public std::false_type
    {

    };
    template <typename First>
    class tester<First>: public std::true_type
    {
        void tester_fn(decltype(First::member));
    };    

public:
    enum { value = tester<T>::value };
};

template<typename T1>
void my_function(const std::enable_if_t<has_member<T1>::value, T1> &obj)
{
    cout<<"Function for classes with member"<<endl;
}

template<typename T1>
void my_function(const std::enable_if_t<!has_member<T1>::value, T1> &obj)
{
    cout<<"Function for classes …

我正在尝试为矢量定义一个哈希.我有一个简单类型的主要模板,以及具有的类的专门化operator().但是,我收到一个错误template parameters not deducible in partial specialization.有人可以指出为什么？

 template <typename T> struct hash<vector<T>>
  {
    size_t operator()(const vector<T> &x) const
    {
        size_t res = 0;

        for(const auto &v:x) {
            boost::hash_combine(res,v);
        }

        return res;
    }
  };

  template <typename T> struct hash<vector<enable_if_t<true_t<decltype(sizeof(declval<T>()()))>::value, T>>>
  {
    size_t operator()(const vector<T> &x) const
    {
        size_t res = 0;

        for(const auto &v:x) {
            boost::hash_combine(res,v());
        }

        return res;
    }
  };

我有以下模板来检查是否有类型std::string.它在GCC上编译得很好,但在Clang上失败了.哪种行为正确？有没有办法让它同时适用？

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

using namespace std;

template <typename T> //Checks if T is string type, by testing for the existence of member type "traits_type"
class is_string
{
public:
    template<typename C> std::false_type test(...);
    template<typename C> std::true_type test(decltype(sizeof(typename C::traits_type)));

    enum {
    value = decltype(((is_string<T>*)nullptr) -> test<T>( sizeof(0) ))::value
    };
};

int main() {
cout<<is_string<string>::value<<endl;
}

Clang错误:

trial.cpp:15:51: error: member access into incomplete type 'is_string<std::basic_string<char> >'
    value = decltype(((is_string<T>*)nullptr) -> test<T>( sizeof(0) ))::value
                                              ^
trial.cpp:20:7: note: in instantiation of template …

我有一个类与成员的const重载访问器方法.这些访问器是使用声明的decltype,这是我的同事遵循的惯例.现在,我需要创建一个指向访问器函数的const版本的指针.我正在尝试使用result_of来做到这一点,但我没有取得任何成功.有人可以帮忙吗？

#include<type_traits>

class A{
    int _member;
    public:
    const decltype(_member) &member() const;
    decltype(_member) &member();    
};

std::result_of<static_cast<const A *>(nullptr)->member()>::type (A::*fnPtr)() const = &A::member;

我有以下代码来检查某个值是否属于值列表。例如：contains({1,2,3},3). 几乎总是，我可以写一堆if-elses。该方法会对性能造成多大影响contains？有办法避免这种情况吗？

template<typename T1,typename T2>
std::enable_if_t<std::is_same<std::initializer_list<T2>,T1>::value, bool> contains(const T1 &container,const T2 &item)
{
    return(std::find(container.begin(),container.end(),item)!=container.end());
}