小编Fra*_*ler的帖子

我正在为类创建一个函数,并且参数被声明为void*但是在我需要测试的函数中,如果这个void*是shared_ptr还是unique_ptr,是否有办法测试这种情况？

这就是我到目前为止所做的工作; 我的类是模板类型,不存储任何成员变量.它有一个默认的构造函数,它也可以通过传入一个shared_ptr<Type>或一个来构造,unique_ptr<Type>并且它具有多个allocate()函数,它们执行相同类型的工作.

#ifndef ALLOCATOR_H
#define ALLOCATOR_H

#include <memory>
#include <iostream>

template<class Type>
class Allocator {
public:
    Allocator(){}
    Allocator( Type type, void* pPtr );
    Allocator( std::shared_ptr<Type>& pType );
    Allocator( std::unique_ptr<Type>& pType );
    // ~Allocator(); // Default Okay

    void allocate( std::shared_ptr<Type>& pType );
    void allocate( std::unique_ptr<Type>& pType );
    void allocate( Type type, void* pPtr );

private:
    Allocator( const Allocator& c ); // Not Implemented
    Allocator& operator=( const Allocator& c ); // Not Implemented

}; // …

我有这样的事情：

template<class T>
class SomeClass {
public:
    typedef std::make_unsigned<T> unsigned_t;
    unsigned_t maxBinBitRep_ { - 1 };    
};

int main() {
    // Okay prints out 255 as expected.
    SomeClass<unsigned char>  unsignedChar;  // unsigned version
    // New to `make_unsigned<>` but should print 255.
    //std::cout << unsignedChar.maxBinBitRep << std::endl; 

    // Should be printing the same as above however it's printing: 4294967295
    SomeClass<char> signedChar;
    // same as above.
    //std::cout << signedChar.maxBinBitRep << std::endl; // signed version


    std::cout << "/nPress any key and enter to …

目前这是伪代码，因为这是我在开始将其编写为完整代码之前正在研究的想法。

我知道我可以创建一个正常的可变参数函数使用va_arg和va_list如printf()确实，但是，我想完全避免使用它们。

我正在考虑使用模板可变参数来代替。我正在考虑使用可变参数制作一个可实例化的类模板。这里的条件是这个类的构造函数只能接受两种类型，但两种类型的数量可以不同。我知道，与编译器的解释方式和调用顺序相比，代码中参数的写入位置是不可知的，但这不是问题。我为参数选择的顺序是出于可读性和一致性目的的约定。

这是伪代码的示例：

class TypeIn {...}
class TypeOut{...}

template<typename... T1, typename... T2>
class MyObject {
    std::array<TypeIn*> inputs_;
    std::array<TypeOut*> outputs_;
public:
    MyObject(T1&&... inputs, T2&& ... outputs) { ... }
};

因为我仍然在C ++ 17的工作，并没有C ++ 20的概念，模块和协程，只是还没有，这将是最干净最可靠和最有效的方式，以确保T1是TypeIn和T2是一TypeOut类对象并相应地填充数组？我可以使用向量，但是一旦对象被构造，输入和输出的大小就不会改变。

可能的用例是：

using In = TypeIn;
using Out = TypeOut;
MyObject obj( In a, In b, In c, Out x, Out y);

如果可能的话，我宁愿不使用这个语法：

MyObject<In,In,In,Out,Out> obj( In a, In b, In c, Out …

我写了这个简单的辅助constexpr函数：

#include <cstdint>

constexpr bool isEven(uint32_t value) { return ((value%2) == 0); }

这非常简单。我想知道这是否被认为是确定某个整数值是奇数还是偶数的最有效方法？目前我并不担心为不同的积分类型模板化这个函数。我只是在追求效率和性能，同时牢记便携性。

编辑

为了提供一些上下文，我可能会在一个循环中调用这个函数，该循环可以迭代 100,000 次到 100,000,000 次或更多...所以效率是这里的关键，但可移植性仍然是一个因素...

正如其他人在评论或答案中所述，我曾通过检查最低有效位来考虑“按位运算”，但是，我不确定编译器是否会在这种情况下优化模运算符。

关于可移植性，我不确定“字节序”或“整体约定”是否是应该使用实现的主要因素。考虑一个仅实现 1 的补码而不是 2 的补码的系统，或者使用 Big Endian 而不是 Little 的系统，可能需要加以考虑。

请考虑以下用于整数类型的代码:

template <class T>
std::string as_binary_string( T value ) {
    return std::bitset<sizeof( T ) * 8>( value ).to_string();
}

int main() {
    unsigned char a(2);
    char          b(4);

    unsigned short c(2);
    short          d(4);

    unsigned int   e(2);
    int            f(4);

    unsigned long long g(2);
    long long h(4);

    std::cout << "a = " << +a << " " << as_binary_string( a ) << std::endl;
    std::cout << "b = " << +b << " " << as_binary_string( b ) << std::endl;
    std::cout << "c = …