小编And*_*rew的帖子

我想存储一个指向对象的指针和一个指向它的已知签名方法的指针.如果我知道该类,那么这个指针有类型:

int (MyClass::*pt2Member)(float, char, char)

但是,如果我不知道类型,我怎么能存储指针？

我想做这样的事情:

myObject.callThisFuncLater(&otherObject, &otherObject::method)

我怎么能存放指向方法method在myObject后来又打电话了吗？

我在项目目录中创建了一个存储库.我添加了所有文件并做了一些提交.然后我将新文件添加到项目和存储库中.之后我回到了早期版本,现在我无法更新到最新版本.之后hg update tip我得到这个消息:

abort: untracked file in working directory differs from file in requested
revision: '.DS_Store'

我是善变的新手.我怎样才能解决这个问题？

假设我们需要一个返回某些东西的函数.但是找不到东西.我看到了选项:

1. T find(bool &ok); //return default T value if not found

我们可以制作一个结构:

template <typename T>
class CheckableValue
{
public:
    CheckableValue(),
    _hasValue(false)
    {

    }
    CheckableValue(const T &t):
    _value(t),
    _hasValue(true)
    {

    }

    inline bool hasValue() const {return _hasValue}
    const T &value() const
    {
        assert(hasValue());
        return _value;
    }

private:
    T _value;
    bool _hasValue;
};

并使功能:

2. CheckableValue<T> find();

或者我们可以使用:

3.boost::tuple<bool, T> find()

你觉得什么更好？

我知道如何创建一个多元数组标准方式:

const int m = 12;
const int y = 3;
int sales[y][n];

而且我知道如何创建指向一个维度数组的指针:

int * ms = new int[m];

但是有可能创建一个指向多重阵列的指针吗？

int * sales = new int[y][m];   // doesn't work
int * mSales = new int[m];    // ok
int * ySales = new int[y];    // ok
mSales * ySales = new mSales[y];    // doesn't work, mSales is not a type

如何创建这样的指针？

有什么方法/工具可以用来检查我的iphone应用程序是否没有内存泄漏？或者如何找到并修复它们？

假设我们有两个功能:

int f();
int g();

我想得到f()和g()的总和.

第一种方式:

int fRes = f();
int gRes = g();
int sum = fRes + gRes;

第二种方式:

int sum = f() + g();

在这两种情况下,性能会有什么不同吗？

复杂类型而不是整数的相同问题

编辑

我理解正确吗？在这种情况下我不应该担心性能(在每种情况下包括经常执行的任务)并使用临时变量来提高可读性并简化代码？

我想写一个符号函数模板.我是这样做的:

template<class T> T sign(const T &value)
{
    if (value > 0) return 1;
    else if (value < 0) return -1;
    return 0;
}

它正在工作,但我不确定当实际上我的函数应该返回T时返回数值是否合适.这个函数好吗？

我创建了.hgignore文件.但忘了.db文件.所以在hg add添加这些文件后进行跟踪.我找到了remove命令,但无法弄清楚如何.db使用单个命令删除所有命令

我正在阅读"C++模板完整指南"一书,部分内容涉及元编程.有一个循环展开的例子(17.7).我已经实现了点积计算程序:

#include <iostream>
#include <sys/time.h>

using namespace std;

template<int DIM, typename T>
struct Functor
{
    static T dot_product(T *a, T *b)
    {
        return *a * *b + Functor<DIM - 1, T>::dot_product(a + 1, b + 1);
    }
};

template<typename T>
struct Functor<1, T>
{
    static T dot_product(T *a, T *b)
    {
        return *a * *b;
    }
};


template<int DIM, typename T>
T dot_product(T *a, T *b)
{
    return Functor<DIM, T>::dot_product(a, b);
}

double dot_product(int DIM, double *a, double *b)
{ …

我前段时间问过这些问题： 从基类到不同派生类的多重继承转换

但我仍然不确定我是否理解答案。问题是：下面的代码有效吗？

#include <iostream>

using namespace std;

struct Base
{
    virtual void printName() 
    {
        cout << "Base" << endl;
    }
};

struct Interface
{
    virtual void foo()
    {
        cout << "Foo function" << endl;
    }
};

struct Derived : public Base, public Interface
{
    virtual void printName()
    {
        cout << "Derived" << endl;
    }
};

int main(int argc, const char * argv[])
{
    Base *b = new Derived();
    Interface *i = dynamic_cast<Interface*>(b);
    i->foo();

    return 0;
}

代码按我的意愿工作。但据我所知，根据上一个问题，它不应该。所以我不确定这样的代码是否有效。谢谢！