tr1

Link TR1 on Ubuntu?

依然范特西╮ — Sat, 04 Jan 2020 16:41:43 +0000

Link TR1 on Ubuntu? 依然范特西╮ 2020-01-05 00:41:43

问题

I have written a class using std::tr1::regex, and I don't know how to link it. I get (sorry for the large dump...) :

$ g++ DictReader.cpp -std=c++0x
/usr/include/c++/4.4/tr1_impl/regex:2255: warning: inline function ‘bool std::tr1::regex_search(_Bi_iter, _Bi_iter, std::tr1::match_results<_Bi_iter, _Allocator>&, const std::tr1::basic_regex<_Ch_type, _Rx_traits>&, std::tr1::regex_constants::match_flag_type) [with _Bi_iter = __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, _Allocator = std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, _Ch_type = char, _Rx_traits = std::tr1::regex_traits<char>]’ used but never defined
/usr/lib/gcc/x86_64-linux-gnu/4.4.1/../../../../lib/crt1.o: In function `_start':
/build/buildd/eglibc-2.10.1/csu/../sysdeps/x86_64/elf/start.S:109: undefined reference to `main'
/tmp/ccgBkWlK.o: In function `DictReader::operator++(int)':
DictReader.cpp:(.text+0xb2a): undefined reference to `bool std::tr1::regex_search<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, char, std::tr1::regex_traits<char> >(__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::match_results<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > >&, std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&, std::bitset<11ul>)'
/tmp/ccgBkWlK.o: In function `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(char const*, unsigned int)':
DictReader.cpp:(.text._ZNSt3tr111basic_regexIcNS_12regex_traitsIcEEEC1EPKcj[std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(char const*, unsigned int)]+0x75): undefined reference to `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::_M_compile()'
/tmp/ccgBkWlK.o: In function `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&)':
DictReader.cpp:(.text._ZNSt3tr111basic_regexIcNS_12regex_traitsIcEEEC1ERKS3_[std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&)]+0x60): undefined reference to `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::_M_compile()'
collect2: ld returned 1 exit status.

What should I link against?

回答1:

This is a linker error, it does not found the function you are using. TR1 is still new so it may not be implemented everywhere. I recommend you to use the boost regex library instead.

来源：https://stackoverflow.com/questions/2398994/link-tr1-on-ubuntu

标签

c++

tr1

Link TR1 on Ubuntu?

只谈情不闲聊 — Sat, 04 Jan 2020 16:40:08 +0000

Link TR1 on Ubuntu? 只谈情不闲聊 2020-01-05 00:40:08

问题

I have written a class using std::tr1::regex, and I don't know how to link it. I get (sorry for the large dump...) :

$ g++ DictReader.cpp -std=c++0x
/usr/include/c++/4.4/tr1_impl/regex:2255: warning: inline function ‘bool std::tr1::regex_search(_Bi_iter, _Bi_iter, std::tr1::match_results<_Bi_iter, _Allocator>&, const std::tr1::basic_regex<_Ch_type, _Rx_traits>&, std::tr1::regex_constants::match_flag_type) [with _Bi_iter = __gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, _Allocator = std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<const char*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, _Ch_type = char, _Rx_traits = std::tr1::regex_traits<char>]’ used but never defined
/usr/lib/gcc/x86_64-linux-gnu/4.4.1/../../../../lib/crt1.o: In function `_start':
/build/buildd/eglibc-2.10.1/csu/../sysdeps/x86_64/elf/start.S:109: undefined reference to `main'
/tmp/ccgBkWlK.o: In function `DictReader::operator++(int)':
DictReader.cpp:(.text+0xb2a): undefined reference to `bool std::tr1::regex_search<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > >, char, std::tr1::regex_traits<char> >(__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, __gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::tr1::match_results<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > >, std::allocator<std::tr1::sub_match<__gnu_cxx::__normal_iterator<char const*, std::basic_string<char, std::char_traits<char>, std::allocator<char> > > > > >&, std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&, std::bitset<11ul>)'
/tmp/ccgBkWlK.o: In function `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(char const*, unsigned int)':
DictReader.cpp:(.text._ZNSt3tr111basic_regexIcNS_12regex_traitsIcEEEC1EPKcj[std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(char const*, unsigned int)]+0x75): undefined reference to `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::_M_compile()'
/tmp/ccgBkWlK.o: In function `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&)':
DictReader.cpp:(.text._ZNSt3tr111basic_regexIcNS_12regex_traitsIcEEEC1ERKS3_[std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::basic_regex(std::tr1::basic_regex<char, std::tr1::regex_traits<char> > const&)]+0x60): undefined reference to `std::tr1::basic_regex<char, std::tr1::regex_traits<char> >::_M_compile()'
collect2: ld returned 1 exit status.

What should I link against?

回答1:

This is a linker error, it does not found the function you are using. TR1 is still new so it may not be implemented everywhere. I recommend you to use the boost regex library instead.

来源：https://stackoverflow.com/questions/2398994/link-tr1-on-ubuntu

标签

c++

tr1

How does one include TR1?

蹲街弑〆低调 — Tue, 31 Dec 2019 03:27:52 +0000

How does one include TR1? 蹲街弑〆低调 2019-12-31 11:27:52

问题

Different compilers seem to have different ideas about TR1. G++ only seems to accept includes of the type:

#include <tr1/unordered_map>
#include <tr1/memory>
...

While Microsofts compiler only accept:

#include <unordered_map>
#include <memory>
...

As for as I understand TR1, the Microsoft way is the correct one.

Is there a way to get G++ to accept the second version? How does one in general handle TR1 in a portable way?

回答1:

Install boost on your machine.
Add the following directory to your search path.

<Boost Install Directory>/boost/tr1/tr1

see here boost tr1 for details

Now when you include <memory> you get the tr1 version of memory that has std::tr1::shared_ptr and then it includes the platform specific version of <memory> to get all the normal goodies.

回答2:

#ifdef _WIN32
    #include <unordered_map>
    #include <memory>
#else
    #include <tr1/unordered_map>
    #include <trl/memory>
#endif

回答3:

Perhaps the best way would be to simply use boost libraries for now, as in many cases they have alternatives with a similar interface to TR1 features, and are just in a different (but consistent) header path and namespace. This has the advantage of working on compilers that haven't even begun implementing C++0x. And there are plenty of useful boost libraries that aren't in TR1 at all :)

Alternately, on G++, you could try passing --std=gnu++0x on the command line. This works for <unordered_set> and <unordered_map>, at least. Then to make it available in std::tr1:

namespace std { namespace tr1 { using namespace std; } }

This is evil, naturally. I highly recommend the boost approach instead :)

回答4:

A tad hacky perhaps, but you could simply add the compiler tr1 directory to your include path.

回答5:

If under Windows, add the 'tr1' directory to the system path. Then #include <memory> should work.

回答6:

I asked myself the same question. Unfortunately, the technical report doesn't say how the headers should be included. It only defines that the extensions should be in the ::std::tr1 namespace.

来源：https://stackoverflow.com/questions/1228402/how-does-one-include-tr1

标签

Difference in performance between map and unordered_map in c++

独自空忆成欢 — Sun, 29 Dec 2019 17:46:27 +0000

Difference in performance between map and unordered_map in c++ 独自空忆成欢 2019-12-30 01:46:27

问题

I have a simple requirement, i need a map of type . however i need fastest theoretically possible retrieval time.

i used both map and the new proposed unordered_map from tr1 i found that at least while parsing a file and creating the map, by inserting an element at at time.

map took only 2 minutes while unordered_map took 5 mins.

As i it is going to be part of a code to be executed on Hadoop cluster and will contain ~100 million entries, i need smallest possible retrieval time.

Also another helpful information: currently the data (keys) which is being inserted is range of integers from 1,2,... to ~10 million.

I can also impose user to specify max value and to use order as above, will that significantly effect my implementation? (i heard map is based on rb trees and inserting in increasing order leads to better performance (or worst?) )

here is the code

map<int,int> Label // this is being changed to unordered_map  
fstream LabelFile("Labels.txt");  


// Creating the map from the Label.txt  
if (LabelFile.is_open())  
{  
    while (! LabelFile.eof() )  
    {             
        getline (LabelFile,inputLine);  
        try  
        {  
            curnode=inputLine.substr(0,inputLine.find_first_of("\t"));  
            nodelabel=inputLine.substr(inputLine.find_first_of("\t")+1,inputLine.size()-1);  
            Label[atoi(curnode.c_str())]=atoi(nodelabel.c_str());  
        }  
        catch(char* strerr)  
        {  
            failed=true;  
            break;  
        }  
    }  
    LabelFile.close(); 
}

Tentative Solution: After review of comments and answers, i believe a Dynamic C++ array would be the best option, since the implementation will use dense keys. Thanks

回答1:

Insertion for unordered_map should be O(1) and retrieval should be roughly O(1), (its essentially a hash-table).

Your timings as a result are way OFF, or there is something WRONG with your implementation or usage of unordered_map.

You need to provide some more information, and possibly how you are using the container.

As per section 6.3 of n1836 the complexities for insertion/retreival are given:

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1836.pdf

One issue you should consider is that your implementation may need to continually be rehashing the structure, as you say you have 100mil+ items. In that case when instantiating the container, if you have a rough idea about how many "unique" elements will be inserted into the container, you can pass that in as a parameter to the constructor and the container will be instantiated accordingly with a bucket-table of appropriate size.

回答2:

The extra time loading the unordered_map is due to dynamic array resizing. The resizing schedule is to double the number of cells each when the table exceeds it's load factor. So from an empty table, expect O(lg n) copies of the entire data table. You can eliminate these extra copies by sizing the hash table upfront. Specifically

Label.reserve(expected_number_of_entries / Label.max_load_factor());

Dividing by the max_load_factor is to account for the empty cells that are necessary for the hash table to operate.

回答3:

unordered_map (at least in most implementations) gives fast retrieval, but relatively poor insertion speed compared to map. A tree is generally at its best when the data is randomly ordered, and at its worst when the data is ordered (you constantly insert at one end of the tree, increasing the frequency of re-balancing).

Given that it's ~10 million total entries, you could just allocate a large enough array, and get really fast lookups -- assuming enough physical memory that it didn't cause thrashing, but that's not a huge amount of memory by modern standards.

Edit: yes, a vector is basically a dynamic array.

Edit2: The code you've added some some problems. Your while (! LabelFile.eof() ) is broken. You normally want to do something like while (LabelFile >> inputdata) instead. You're also reading the data somewhat inefficiently -- what you apparently expecting is two numbers separated by a tab. That being the case, I'd write the loop something like:

while (LabelFile >> node >> label)
    Label[node] = label;

来源：https://stackoverflow.com/questions/2350248/difference-in-performance-between-map-and-unordered-map-in-c

标签

How does weak_ptr work?

时间秒杀一切 — Fri, 27 Dec 2019 18:26:26 +0000

How does weak_ptr work? 时间秒杀一切 2019-12-28 02:26:26

问题

I understand how to use weak_ptr and shared_ptr. I understand how shared_ptr works, by counting the number of references in its object. How does weak_ptr work? I tried reading through the boost source code, and I'm not familiar enough with boost to understand all the things it uses.

Thanks.

回答1:

shared_ptr uses an extra "counter" object (aka. "shared count" or "control block") to store the reference count. (BTW: that "counter" object also stores the deleter.)

Every shared_ptr and weak_ptr contains a pointer to the actual pointee, and a second pointer to the "counter" object.

To implement weak_ptr, the "counter" object stores two different counters:

The "use count" is the number of shared_ptr instances pointing to the object.
The "weak count" is the number of weak_ptr instances pointing to the object, plus one if the "use count" is still > 0.

The pointee is deleted when the "use count" reaches zero.

The "counter" helper object is deleted when the "weak count" reaches zero (which means the "use count" must also be zero, see above).

When you try to obtain a shared_ptr from a weak_ptr, the library atomically checks the "use count", and if it's > 0 increments it. If that succeeds you get your shared_ptr. If the "use count" was already zero you get an empty shared_ptr instance instead.

EDIT: Now, why do they add one to the weak count instead of just releasing the "counter" object when both counts drop to zero? Good question.

The alternative would be to delete the "counter" object when both the "use count" and the "weak count" drop to zero. Here's the first reason: Checking two (pointer sized) counters atomically is not possible on every platform, and even where it is, it's more complicated than checking just one counter.

Another reason is that the deleter must stay valid until it has finished executing. Since the deleter is stored in the "counter" object, that means the "counter" object must stay valid. Consider what could happen if there is one shared_ptr and one weak_ptr to some object, and they are reset at the same time in concurrent threads. Let's say the shared_ptr comes first. It decreases the "use count" to zero, and begins executing the deleter. Now the weak_ptr decreases the "weak count" to zero, and finds the "use count" is zero as well. So it deletes the "counter" object, and with it the deleter. While the deleter is still running.

Of course there would be different ways to assure that the "counter" object stays alive, but I think increasing the "weak count" by one is a very elegant and intuitive solution. The "weak count" becomes the reference count for the "counter" object. And since shared_ptrs reference the counter object too, they too have to increment the "weak count".

A probably even more intuitive solution would be to increment the "weak count" for every single shared_ptr, since every single shared_ptr hold's a reference to the "counter" object.

Adding one for all shared_ptr instances is just an optimization (saves one atomic increment/decrement when copying/assigning shared_ptr instances).

回答2:

Basically, a "weak_ptr" is an ordinary "T*" pointer that lets you RECOVER a strong reference, i.e. "shared_ptr", later in the code.

Just like an ordinary T*, the weak_ptr doesn't do any reference-counting. Internally, to support reference-counting on an arbitrary type T, the STL (or any other library implementing this kind of logic) creates a wrapper object we'll call "Anchor". "Anchor" exists solely to implement the reference count and "when count is zero, call delete" behavior we need.

In a strong reference, the shared_ptr implements its copy, operator=, constructor, destructor, and other pertinent APIs to update "Anchor"'s reference count. This is how a shared_ptr ensures that your "T" lives for exactly as long as somebody is using it. In a "weak_ptr", those same APIs just copy the actual Anchor ptr around. They do NOT update reference counts.

This is why the most important APIs of "weak_ptr" are "expired" and the poorly-named "lock". "Expired" tells you if the underlying object is still around- i.e. "Has it already deleted itself because all strong references went out of scope?". "Lock" will (if it can) convert the weak_ptr to a strong reference shared_ptr, restoring reference-counting.

BTW, "lock" is a terrible name for that API. You aren't (just) invoking a mutex, you're creating a strong reference from a weak one, with that "Anchor" acting. The biggest flaw in both templates is that they did not implement operator->, so to do anything with your object you have to recover the raw "T*". They did this mostly to support things like "shared_ptr", because primitive types don't support the "->" operator.

来源：https://stackoverflow.com/questions/5671241/how-does-weak-ptr-work

标签

TR1 function multicast

╄→尐↘猪︶ㄣ — Tue, 24 Dec 2019 21:19:11 +0000

TR1 function multicast ╄→尐↘猪︶ㄣ 2019-12-25 05:19:11

问题

How would you implement multicast for TR1 functors? I have my callback slots implemented like

void setCallback(std::tr1::function<void (std::string)> cb)
{
    this->callback = cb;
}

but need to pass more than one callback in one of them. I don't want to go into more complex solutions like observer, as this is the only case I need multicast so far. I also cannot use Boost.Signals (as suggested here), because I cannot use Boost. I don't need to explicitly handle disabling callback when subscriber no longer exist.

回答1:

You most likely want:

void registerCallback(std::tr1::function<void (std::string)> cb)
{
    this->callbacks.push_back(cb);
}

with callbacks a container (whichever you like) of std::tr1::function objects instead of a single one. When dispatching, iterate over the callbacks.

Also, if you want to be able to remove callbacks later, you can do something along these lines:

// I use list because I don't want the iterators to be invalid
// after I add / remove elements
std::list<std::function<void(std::string)>> callbacks;

...
typedef std::list<std::function<void(std::string)>>::iterator callback_id;

callback_id register_callback(std::function<void(std::string)> f)
{
    return callbacks.insert(callbacks.end(), f);
}

void unregister_callback(callback_id id)
{
    callbacks.erase(id);
}

回答2:

Put them in a list / vector. If you have to remove them individually you have to wrap them some how (because they are not comparable).

回答3:

Have a sequence of them rather than a single function (i.e. a vector<...>), and when calling back, iterate over the sequence and call.

e.g

std::vector<std::tr1::function<void (std::string)> > callbacks;
auto it = callbacks.begin(), end = callbacks.end();
for(; it != end; ++it)
  (*it)("somestring");

来源：https://stackoverflow.com/questions/7887582/tr1-function-multicast

标签

c++

functor

tr1

Workaround to allow tr1::function to swallow return values

爷，独闯天下 — Tue, 24 Dec 2019 02:55:41 +0000

Workaround to allow tr1::function to swallow return values 爷，独闯天下 2019-12-24 10:55:41

问题

As a follow-up to Can tr1::function swallow return values?, how can one work around the limitation that tr1::function cannot swallow return values?

This should work in the specific case of swallowing the return value of a callable object taking no arguments:

template<typename FuncT>
struct swallow_return_t
{
  explicit swallow_return_t(FuncT i_Func):m_Func(i_Func){}
  void operator()(){ m_Func(); }
  FuncT m_Func;
};

template<typename FuncT>
swallow_return_t<FuncT>
swallow_return(FuncT f)
{
  return swallow_return_t<FuncT>(f);
}

Then use like:

int Foo();
std::tr1::function<void()> Bar = swallow_return(Foo);

I assume variadic templates and perfect forwarding would permit generalization of this technique to arbitrary parameter lists. Is there a better way?

回答1:

The following works for me in GCC 4.6.1:

#include <functional>

int foo() { return 5; }
int goo(double, char) { return 5; }

int main()
{
  std::function<void()> f = foo;
  std::function<void(float, int)> g = goo;
  (void)f();
  (void)g(1.0f, 'a');
}

Here's a wrapper using lambdas, but it's not automagic yet

template <typename T, typename ...Args>
struct strip_return
{
  static inline std::function<void(Args...)> make_function(std::function<T(Args...)> f)
  {
    return [&f](Args... args) -> void { f(args...); };
  }
};

int main()
{
  auto q = strip_return<int>::make_function(std::bind(foo));
  q();
}

Forget the middle part. OK, since std::function is type-erasing, it's hard to get at the underlying types. However, if you go for the function reference directly, you can avoid these problems entirely:

template <typename T, typename ...Args>
static inline std::function<void(Args...)> make_direct(T (&f)(Args...))
{
  return [&f](Args... args) -> void { f(args...); };
}

int main()
{
  auto p = make_direct(foo);
  q();
}

来源：https://stackoverflow.com/questions/6653531/workaround-to-allow-tr1function-to-swallow-return-values

标签

c++

c++11

tr1

C++ how to handle tr1 and non-tr1 namespaces in portable code?

允我心安 — Mon, 23 Dec 2019 21:04:05 +0000

C++ how to handle tr1 and non-tr1 namespaces in portable code? 允我心安 2019-12-24 05:04:05

问题

Is there a canonical way to deal with the namespace issues that arise when trying to maintain portable code between a TR1 and non-TR1 toolchain?

I have a VC++2010 project that #include <type_traits>. I also have an LLVM 3.0 compiler that can handle this fine. This allows me to use templates such as:

std::enable_if<typename>
std::is_enum<typename>

However I also need to build and maintain this code on an Xcode 4.5 clang compiler:

$ /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang --version
Apple clang version 4.1 (tags/Apple/clang-421.11.66) (based on LLVM 3.1svn)
Target: x86_64-apple-darwin11.4.2
Thread model: posix

This compiler doesn't seem to have a include file, instead it has a . However this is causing me problems because the namespace has changed from std:: to __gnu_cxx::, meaning I have to use:

__gnu_cxx::__enable_if<typename>

Somehow I was able to determine that the definition of the symbol __GLIBCXX__ is sufficient to determine whether I should use one or the other (not even sure that's the right way to do it, but for now it works between the compilers I'm using).

So I could resort to using preprocessor macros:

#ifdef __GLIBCXX__
# include <tr1/type_traits>
# define ENABLE_IF __gnu_cxx::__enable_if
#else
# include <type_traits>
# define ENABLE_IF std::enable_if
#endif

But this seems like it might be more of a hack than a proper solution. (Actually I tried this and it doesn't work, because trying to use __gnu_cxx::__enable_if causes this error:

error: too few template arguments for class template '__enable_if'

further digging suggests that this version of enable_if actually takes two template arguments. I'm now very lost...)

I thought about doing something like:

#ifdef __GLIBCXX__
# include <tr1/type_traits>
namespace __gnu_cxx = foo; 
#else
# include <type_traits>
namespace std = foo;
#endif

... foo::enable_if< ... >

However this doesn't work because the template is called enable_if in one namespace, but __enable_if in the other.

I'm sure I'm not the first person to deal with this problem - can someone point me at the industry best practice for resolving this please? Or should I just use Boost instead?

There is a similar question (I think) but only a partial answer here. Are there better options?

EDIT: I tried this, with <boost/type_traits.hpp>:

#include <boost/type_traits.hpp>

template <typename ValueType>
class Extractor <ValueType, typename boost::enable_if<boost::is_enum<ValueType>::value>::type> {
 public:
  ValueType extract(double value) {
    return static_cast<ValueType>(static_cast<int>(value));  // cast to int first, then enum, to satisfy VC++2010
  }
};

enum MyEnum { Enum0, Enum1 };
Extractor<MyEnum> e;
MyEnum ev = e.extract(1.0);

However this gives me the following compiler error in Xcode 4.5:

error: expected a qualified name after 'typename'
  class Extractor <ValueType, typename boost::enable_if<boost::is_enum<ValueType>::value>::type> {
                                                                                           ^
error: unknown type name 'type'

So it doesn't seem that std::enable_if and boost::enable_if are drop-in compatible.

回答1:

I'll answer my own question as I did get something working using boost::enable_if_c (note that the drop-in replacement for std::enable_if is boost::enable_if_c, not boost::enable_if).

#include <boost/utility/enable_if.hpp>
#include <boost/type_traits/is_enum.hpp>

// this would work except one of my environments doesn't contain <complex> so it's
// too inclusive. Better (for me) to use the more specific includes above.
// #include <boost/type_traits.hpp>  

template <typename ValueType>
class Extractor <ValueType, typename boost::enable_if_c<boost::is_enum<ValueType>::value>::type> {
 public:
  ValueType extract(double value) {
    return static_cast<ValueType>(static_cast<int>(value));  // cast to int first, then enum, to satisfy VC++2010
  }
};

However I'm still very curious to know whether there is a better way to deal with this than resorting to Boost.

来源：https://stackoverflow.com/questions/14823832/c-how-to-handle-tr1-and-non-tr1-namespaces-in-portable-code

标签

Boost Serialization - Serialize std::tr1::shared_ptr?

核能气质少年 — Mon, 23 Dec 2019 19:06:04 +0000

Boost Serialization - Serialize std::tr1::shared_ptr? 核能气质少年 2019-12-24 03:06:04

问题

Boost::Serialization has builtin support for boost::shared_ptr<>.

Is there a way to use this support for std::tr1::shared_ptr<> too?
Is it possible to cast from std::tr1::shared_ptr<> to boost::shared_ptr<>?

回答1:

A casting will not be possible as implementations differ. Also creating an instance of the one shared_ptr type with the value returned from get() on the other shared_ptr type will not work correctly as the reference countings will go to 0 at different points in your code which leads to deletion of the object before the last use of it. I am not an expert of boost::serialization but as the interfaces of std::tr1::shared_ptr<> and boost::shared_ptr<> are nearly identical it is very likely that you can just clone the serialization/deserialization code of boost::shared_ptr<> and only have to replace the namespace of the shared_ptr.

来源：https://stackoverflow.com/questions/4094604/boost-serialization-serialize-stdtr1shared-ptr

标签

out of range random number generation in C++ using tr1

假装没事ソ — Mon, 23 Dec 2019 18:27:33 +0000

out of range random number generation in C++ using tr1 假装没事ソ 2019-12-24 02:27:33

问题

I am trying to generate number from a uniform distribution of real number in the range of [0, 1). But compiler is generating numbers which are out of [0, 1) range.

Here is the code:

int main(void) {
    // Solver solve;

    mt19937 mteng;
    mteng.seed(rdtsc());
    uniform_real<double> uniRealD;

    double randomNum;

    for (int index = 0; index < 10; index++){
        randomNum = uniRealD(mteng);

        if(randomNum<0.5)
            cout<<index<<" no. random number is: "<<randomNum<<endl;
        else
            cout<<"number generate is not in range"<<endl;
    }

    return 0;
}

Any comments on what could be wrong with the code? I am using rdtsc() as seed.

回答1:

I had to get rid of your seed function, rdtsc(), make some includes, introduce a using namespace std, and change a 0.5 to 1.0, and change uniform_real to uniform_real_distribution, but after that, using libc++, I get:

#include <random>
#include <iostream>

using namespace std;

int main(void) {
    // Solver solve;

    mt19937 mteng;
    mteng.seed(0);
    uniform_real_distribution<double> uniRealD;

    double randomNum;

    for (int index = 0; index < 10; index++){
        randomNum = uniRealD(mteng);

        if(randomNum<1.0)
            cout<<index<<" no. random number is: "<<randomNum<<endl;
        else
            cout<<"number generate is not in range"<<endl;
    }

    return 0;
}

0 no. random number is: 0.592845
1 no. random number is: 0.844266
2 no. random number is: 0.857946
3 no. random number is: 0.847252
4 no. random number is: 0.623564
5 no. random number is: 0.384382
6 no. random number is: 0.297535
7 no. random number is: 0.056713
8 no. random number is: 0.272656
9 no. random number is: 0.477665

回答2:

Your code shouldn't be doing that. Probably a bug in the implementation. What compiler and library versions? Try moving away from tr1 to C++11.

回答3:

    if(randomNum<0.5)
        cout<<index<<" no. random number is: "<<randomNum<<endl;
    else
        cout<<"number generate is not in range"<<endl;

Change the if statement to if(randomNum < 1.)

来源：https://stackoverflow.com/questions/10133832/out-of-range-random-number-generation-in-c-using-tr1

标签