小编Mic*_*hoi的帖子

我只是试图使用java在eclipse中显示一些unicode象棋符号,但是它只是打印出随机矩形,除非棋子最近在样式上进行了彻底改变 - 我不认为它是我想要的.非常感谢帮助!

我的代码:

import java.io.PrintStream;
import java.io.UnsupportedEncodingException;

public class ChessSymbols {
public static void main (String [ ] args)throws
UnsupportedEncodingException {
        String unicodeMessage =
                        "\u2654 " + // white king
                        "\u2655 " + // white queen
                        "\u2656 " + // white rook
                        "\u2657 " + // white bishop
                        "\u2658 " + // white knight
                        "\u2659 " + // white pawn
                        "\n" +
                        "\u265A " + // black king
                        "\u265B " + // black queen
                        "\u265C " + // black …

如果我有一些微不足道的事情(并澄清,我并不是说这是一个很好的实现,只是一个例子来证明成员函数的部分模板特化失败):

template <typename T, typename U>
class BankAccount
{
  T money;
  U interestRate;
public:
  BankAccount(T money, U interestRate) :
    money(money), interestRate(interestRate)
  {}

  void showMeTheMoney();
};

我不能通过以下方式专门化每个功能:

// invalid code
template <typename U>
void BankAccount <int, U>::showMeTheMoney()
{
  printf("$%d.00 interest: %f\n", money, interestRate);
}

template <typename U>
void BankAccount <long, U>::showMeTheMoney()
{
  printf("$%l.00 interest: %f\n", money, interestRate);
}

template <typename U>
void BankAccount <float, U>::showMeTheMoney()
{
  printf("$%.2f interest: %f\n", money, interestRate);
}

template <typename U>
void BankAccount <double, U>::showMeTheMoney() …

我想调用std::apply()一个函数；但是，我无法使用，因为std::tuple我使用的当前已包装。例如：

#include <tuple>

template <class T>
struct wrapped
{
    wrapped(T t) : t(t) {}

    T t;
};

template <class T, class ... Args>
struct delay_call
{
    T(*callback)(Args...);
    std::tuple<Args...> params;

    delay_call(T(*callback)(Args...), Args ... params) :
        callback(callback), params(params...)
    {}

    T call()
    {
        return std::apply(callback, params);
    }
};

template <class T, class ... Args>
struct delay_call_with_wrap
{
    T(*callback)(Args...);
    std::tuple<wrapped<Args>...> w_params;

    delay_call_with_wrap(T(*callback)(Args...), wrapped<Args> ... w_params) :
        callback(callback), w_params(w_params...)
    {}

    T call()
    {
        std::tuple<Args...> params; // = w_params.t
        return std::apply(callback, actual_params); …

我的问题是扩展这个:为什么lambdas可以通过编译器比普通函数更好地优化？

重申一下,结论是lambdas创建了不同的特化,编译器可以简单地内联,而函数指针不像内联那么容易,因为对于一组函数原型只有一个特化.考虑到这一点,将函数指针模板作为快速/更快的lambdas？

int add(int a, int b) { return a + b; }
int sub(int a, int b) { return a - b; }

template <class F>
int operate(int a, int b, F func)
{
    return func(a, b);
}

template <int func(int, int)>
int operateFuncTemplate(int a, int b)
{
    return func(a, b);
}

int main()
{
    // hard to inline (can't determine statically if operate's f is add or sub since its just a function pointer)
    auto addWithFuncP = …

我想减少引用函数所需的语法量,并且想知道是否有办法做类似的事情:

(不可编译)

using pushToLastUsed = mSomeLongStackFIFOObject.push_back;
// or
auto pushToLastUsed = mSomeLongStackFIFOObject.push_back;

然后我可以这样:

pushToLastUsed(10);

代替:

mSomeLongStackFIFOObject.push_back(10);

当然我可以制作一个像:

#define pushToLastUsed mSomeLongStackFIFOObject.push_back

// some code using it here

#undef pushToLastUsed

但我不想使用宏.