为了账号安全,请及时绑定邮箱和手机立即绑定

boost:tr1与std:tr1冲突了怎么办?

/ 猿问

boost:tr1与std:tr1冲突了怎么办?

皈依舞 2019-05-16 15:11:06

boost:tr1与std:tr1冲突了怎么办


查看完整描述

4 回答

?
慕容708150

最近用boost::math库,发现会和我以前的程序冲突。比如我的程序如果用到

#include<tr1/unordered_map> 等等std::tr1名字域下的东西。。。

google了下,原因是boost::tr1设计初衷是为了在你的系统没有std::tr1标准库实现的情况下让你仍然可以在程序中使用std::tr1::unordered_map, std::tr1::tuple等东东,当然了这是一个work around,也就是你其实还是用的boost::tuple等等

只是你的代码写的时候可以写std::tr1::tuple。

比如boost的math库的一个分布函数的实现

/usr/include/boost/math/special_functions/detail/igamma_inverse.hpp

在该文件第13行

#include <boost/tr1/tuple.hpp>

然后下面它就用到了tuple使用如下

std::tr1::tuple<T, T, T> operator() (const T& x) const //其实呢还是用的boost::下面的tuple看下/usr/include/boost/tr1/tuple.hpp

namespace std{ namespace tr1{

using ::boost::fusion::tuple;

// [6.1.3.2] Tuple creation functions
using ::boost::fusion::ignore;
using ::boost::fusion::make_tuple;
using ::boost::fusion::tie;
using ::boost::fusion::get;

// [6.1.3.3] Tuple helper classes
using ::boost::fusion::tuple_size;
using ::boost::fusion::tuple_element;

}}

这就是work around的方法。

现在问题来了,我的GCC已经有std::tr1的实现了,比如<tr1/unordered_map> ,那么着就会带来命名冲突了,比如同时又两个tuple定义了。。。。boost::fusion::tuple和原生的std::tr1::tuple。

见boost::tr1的文档

实现
如果 Boost.TR1 被配置 为使用你的标准库中的原生 TR1 实现,则它不需要做多少事情:它只是包含适当的头文件就行了。

如果 Boost.TR1 使用了某个组件的 Boost 实现,则它需要包含适当的 Boost 头文件并使用声明将所需的名字导入到 namespace std::tr1 中。注意,只有作为标准部分的声明会被导入:本实现有意非常严格地没有将所有 Boost-特有的扩展引入到 namespace std::tr1,这是为了能够捕获用户代码中的任何可移植性错误。如果你真的需要使用 Boost-特有的扩展,则你应当直接包含 Boost 头文件,则改用 namespace boost:: 中的声明。注意,本实现的风格并不是完全符合标准的,它不能将用户自定义的 TR1 组件的模板特化增加到 namespace std::tr1 中。还有一到两个 Boost 库尚未完全符合标准,任何与标准不符的地方都已在 "TR1 的分类"一节 中说明。不过幸好,这些不符合标准的行为在实际中极少会用到。

如果你使用标准的头文件包含(在 boost/tr1/tr1 中),则这些头文件名有时可能与现有的标准库头文件冲突(例如 shared_ptr 已增加到现有的标准库头文件 <memory> 中而不是它自己的头文件)。这些头文件可以用以下两种方法之一前转到现有的标准库头文件:对于 gcc,使用 #include_next, 而对于其它编译器则使用宏BOOST_TR1_STD_HEADER(header) (在 boost/tr1/detail/config.hpp 中定义),它将扩展为 #include <../include/header>. 对于大多数编译器,这样就可以直接使用,但是这意味着这些头文件不能被放在名为"include"且已在你的编译器搜索路径中的目录下。

怎么解决冲突问题呢,还是没有完全弄明白,不过解决办法还是google到了。。 OK 解决了就好。。 以后再说。

按理说按照boost/tr1/tuple.hpp 中所写的

#ifdef BOOST_HAS_TR1_TUPLE

# ifdef BOOST_HAS_INCLUDE_NEXT
# include_next BOOST_TR1_HEADER(tuple)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))
# endif 我应该加一个 #define BOOST_HAS_tR1_TUPLE 就能解决问题 因为 BOOST_TR1_HEADER(tuple) 会被转换为 #include <tr1/tuple> 但是实验不成功。。。。 usr/include/boost/tr1/tuple.hpp:13:43: error: no include path in which to search for tr1/tuple //WHY 知道为什么的帮忙告诉我下,谢谢~ //估计可能是incude_next的原因? 没太仔细看include_next作用TODO 最后google到的解决方案是#define BOOST_HAS_TR1_TUPLE 1
#include <boost/tr1/detail/config.hpp>
#undef BOOST_HAS_INCLUDE_NEXT //似乎是需要屏蔽掉 incude_next



查看完整回答
反对 回复 2019-05-25
?
aluckdog

// 添加下面代码
#define BOOST_HAS_TR1_TUPLE 1
#include <boost/tr1/detail/config.hpp>
#undef BOOST_HAS_INCLUDE_NEXT

查看完整回答
反对 回复 2019-05-25
?
慕用2447696

按理说按照boost/tr1/tuple.hpp 中所写的
#ifdef BOOST_HAS_TR1_TUPLE

# ifdef BOOST_HAS_INCLUDE_NEXT
# include_next BOOST_TR1_HEADER(tuple)
# else
# include <boost/tr1/detail/config_all.hpp>
# include BOOST_TR1_STD_HEADER(BOOST_TR1_PATH(tuple))
# endif

我应该加一个 #define BOOST_HAS_tR1_TUPLE 就能解决问题 因为 BOOST_TR1_HEADER(tuple) 会被转换为 #include <tr1/tuple>
但是实验不成功。。。。

查看完整回答
反对 回复 2019-05-25
?
慕容4345310

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

在C++的TR1中(Technology Report)中包含一个function模板类和bind模板函数,使用它们可以实现类似函数指针的功能,但却却比函数指针更加灵活,特别是函数指向类的非静态成员函数时。可以参考Scott Meyers. <<Effective C++ (3rd Edition)>>. Item 35.下面具体说明其使用方法。

一、指向全局函数或静态成员函数时

因为在本质上讲全局函数和静态成员函数没有区别,使用方法上除了静态成员函数在引用时要在前面加域作用符className::外,没有其它任何区别,事实上全局函数也有可能放入命名空间,或者使用全局域作用符,例如 nameSpace::function() 或::function,这样不仅本质上相同,形势上也与静态成员函数一致了,所以它们是没有区别的,放到一起讨论。

这种情况比较简单,只需要定义一个类型

#include <iostream>

#include <iomanip>

#include <tr1/memory>

#include <tr1/functional>

typedef   std::tr1::function<void (int)>   HandlerEvent;

然后再定义一个成员变量

class Sharp{

public:

    HandlerEvent handlerEvent;

};

然后在其它函数内就可以通过设置handlerEvent的值来动态装载事件响应函数了,如:

class Rectangle{

private:

    std::string name;

    Sharp sharp;

public:

    void initial(void);

    const Sharp getSharp() const;

    static void onEvent(int param){  //---------------(1)

        std::cout << "invode onEvent method,get parameter: " << param << std::endl;

    }

};

//类的实现方法

void Rectangle::initial(){

    sharp.handlerEvent = HandlerEvent(&Rectangle::onEvent); //---------------(2)

    std::cout << "invode initial function!" << std::endl;

}

const Sharp Rectangle::getSharp() const{

    return sharp;

}

//下面为测试函数:

int main(int argc,char *argv[]){

    std::cout <<"hi: " << std::setw(50) << "hello world!" << std::endl;

    Rectangle rectangle;

    rectangle.initial();  //---------------(3)

    rectangle.getSharp().handlerEvent(23);    //---------------(4)

}

//输出结果如下:

hi:                                       hello world!

invode initial function!

invode onEvent method,get parameter: 23    //---------------(5)

  

注意,这里使用了静态成员函数,如果把Rectangle前面的static去掉这段代码不能工作,编译都不能通过,因为静态成员函数与非静态成员函数的参数表不一样,原型相同的非静态函数比静态成员函数多一个参数,即第一个参数this指针,指向所属的对象,任何非静态成员函数的第一个参数都是this指针,所以如果把Rectangle前面的static去掉,其函数原型等效于下面的一个全局函数:

void onEvent(Rectangle* this, int);

所以,这与HandlerEvent所声明的函数类型不匹配,编译将不能通过。而且,既然静态成员函数没有this指针,所以上面(3)处的调用使sharp对象中的handlerEvent使向了Rectangle的静态方法onEvent(),这样当通过(4)处这样调用时就会自动执行(1)处的静态函数onEvent()。

二、std::tr1::bind()模板函数的使用

通过上面的std::tr1::function 可以对静态成员函数进行绑定,但如果要对非静态成员函数的绑定,需用到下机将要介绍的bind()模板函数.

首先说bind的用法,其声明如下所示:

    bind(Function fn, T1 t1, T2 t2, …, TN tN);

其中fn为将被调用的函数,t1…tN为函数的参数。如果不指明参数,则可以使用占位符表示形参,点位符格式为

std::tr1::placehoders::_1,  std::tr1::placehoders::_2,  …,  std::tr1::placehoders::_N

将上例中Rectangle::onEvent(int param)前的static去掉改为非静态成员函数,则进行动态绑定使得程序正常运行,将Rectangle::initial(void)的定义修改为:

void Rectangle::initial(){

    sharp.handlerEvent = std::tr1::bind(&Rectangle::onEvent,this,std::tr1::placeholders::_1);

    std::cout << "invode initial function!" << std::endl;

}

这样,便动态装载函数成功。其它测试数据都不用进行修改。测试结果于上一样。

三、指向虚成员函数的使用

对于虚成员函数的情况与上面第2节所说相同,仍然可以实现虑函数的效果。如果定义类Square继承自Rectangle,将Rectangle::OnEvent重载,定义一个新的Square::OnEvent,Rectangle::initialize中的函数不变,仍然使用Rectangle::OnEvent进进绑定,则调用成员object.onEvent()时,具体执行Rectangle::OnEvent还是Square::OnEvent,看object所属对象的静态类型是Rectangle还是Square而定.

下面为简单示例:

我们首先修改一个上面Rectangle的initial()方法,改为虚函数。如:

 virtual void onEvent(int param){

        std::cout << "invode Rectangle's onEvent method,get parameter: " << param << std::endl;

    }

然后我们再写一个Square类来继承Rectangle类。并重写onEvent方法。如:

class Square : public Rectangle{

public:

void onEvent(int param){

        std::cout << "invode Square's onEvent method,get parameter: " << param << std::endl;

    }

};

测试代码:

int main(int argc,char *argv[]){

    Rectangle rectangle;

    rectangle.initial();

    rectangle.getSharp().handlerEvent(23);

    Square square;

    square.initial();

    square.getSharp().handlerEvent(33);

}

运行后的结果如下:

hi:                                       hello world!

invode initial function!

invode Rectangle's onEvent method,get parameter: 23

invode initial function!

invode Square's onEvent method,get parameter: 33


查看完整回答
反对 回复 2019-05-25

添加回答

回复

举报

0/150
提交
取消
意见反馈 帮助中心 APP下载
官方微信