小编goo*_*ons的帖子

我有一个抽象的单例类。我的目标是任何子类只需要实现 init() 函数而不需要其他任何东西。这是我所做的：

template <typename T>
class Singleton
{
    public: 

        Singleton()
        {
            init();
        }

        static T& instance()
        {
            static T instance;
            return instance;
        }

    protected:
        virtual void init() = 0;   
};

class SubSingleton : public Singleton<SubSingleton>
{
    protected: 
        void init()
        {
            cout << "Init SubSingleton" << endl;
        }
};

这不会编译，因为 init() 受到保护并且不能从公共静态函数调用。这个问题有两种解决方案。首先我们可以将 init() 函数公开，但我不想公开这个函数。所以这就只剩下第二种解决方案了，将子类改成如下：

class SubSingleton : public Singleton<SubSingleton>
{
    friend class Singleton<SubSingleton>;

    protected:

        void init()
        {
            cout << "Init SubSingleton" << endl;
        }
};

这工作得很好，但我不想要朋友声明，因为其他程序员可能会扩展我的代码并且可能不知道应该添加它。

有没有其他方法可以在没有朋友声明的情况下实现这一点？也许安德烈·亚历山德雷斯库有什么东西？

编辑：现在在构造函数中调用 init 函数而不是 …

我有一个模板类.由于在编译期间处理模板,是否可以在编译期间比较模板参数并使用预处理器添加特定代码？像这样的东西:

template<class T>
class MyClass
{
   public:
      void do()
      {
         #if T is equal to vector<int>
            // add vector<int> specific code
         #if T is equal to list<double>
            // add list<double> specific code
         #else
            cout << "Unsupported data type" << endl;
         #endif
      }
};

如何在编译期间将模板类型与另一种类型进行比较,如上例所示？我不想添加处理特定类型的特定子类.

我很惊讶地发现关于这个主题的信息很少。我想检测用户是否正在运行 Android。我正在使用：

platform.dist()

这可以完美地检测所有操作系统和不同的 Linux 发行版。但是，在 Android 上运行它时，它的系统名称始终返回为“Linux”。有没有办法检测Android？我不想包含任何 3rd 方模块，因为这必须尽可能便携。是否有一些特定的 Android 函数可以在 try-catch 中调用？

我正在尝试将多个NULL字符'\ 0'附加到PHP中的字符串中.

$s = 'hello';
while(strlen($s) < 32) $s .= '\0';

但是,PHP添加了2个字符(\和0),而不是转义字符并添加NULL.有没有人知道在字符串中添加NULL字符？

我有两个堆叠的物品。这两个项目都有一个半透明的背景。圆圈现在显示下面的圆形矩形。

有什么办法可以隐藏与圆圈重叠的长圆形矩形的部分吗？也许改变父，圆的背景是从祖先向上拉，因此忽略它下面的矩形？

这是代码：

Item
{
    id: choice1
    width: 300
    height: 100

    Rectangle
    {
        id: choiceLabel1
        width: 0
        height: parent.height / 1.5
        radius: parent.height * 0.5
        color: "#88808080"
        anchors
        {
            verticalCenter: choice1.verticalCenter
            left: choice1.left
            leftMargin: choiceIcon1.width / 2
        }
        border
        {
            width: 2
            color: "red"
        }
    }
    Rectangle
    {
        id: choiceIcon1
        width: choice1.height
        height: choice1.height
        radius: width * 0.5
        color: "#88808080"
        anchors
        {
            verticalCenter: choice1.verticalCenter
            left: choice1.left
        }
        border
        {
            width: 2
            color: "red"
        }
    }
}

我来自 C++ 背景并且经常使用静态变量来减少必须初始化变量的时间数量（特别是如果初始化需要很长时间）。因此，从 StackOverflow 上的其他帖子中，人们建议使用静态类变量如下：

class MyClass(object):

    StaticList1 = [...] # Very large list
    StaticList2 = [...] # Very large list

现在，如果在整个程序执行过程中至少存在 1 个 MyClass 实例并且列表只创建一次，那么这很好。但是，如果在执行的某个阶段没有 MyClass 的实例，Python 似乎会删除静态列表（我假设是因为引用计数器下降到 0）。

所以我的问题是，是否有任何简单的方法不使用外部模块来初始化 StaticList1 和 StaticList2 仅一次（第一次使用它们）并且永远不会删除它们，即使在程序存在之前没有 MyClass 的实例（或者您删除手动列出）？

编辑：

也许我把这个问题简单化了。我在做什么：

class MyClass(object):

    StaticList = None

    def __init__(self, info):
        if self.StaticList == None:
            print "Initializing ..."
            self.StaticList = []
            # Computationally expensive task to add elements to self.StaticList, depending on the value of parameter info

    def data(self):
        return self.StaticList

我从另一个脚本导入模块并有一个这样的循环：

import myclass …

我有这段代码:

const int x = 7;
const int &y = x;

int *z = (int*)&y;
*z = 8;

cout << x<< endl;
cout << y<< endl;
cout << *z<< endl;

其中产生以下输出:

7
8
8

我知道不应该像上面那样删除const.但是,为什么x打印7？我只创建了一个var,所以如果输出显示7和8,那么应该创建2个vars.怎么会有2个不同的数字打印出来.

我想在触发 onclick 事件时从类中调用“成员”函数。onclick 事件本身应该绑定在类中。这就是我所拥有的：

var MyClass = function()
{
    this.value = 'hello';

    this.update = function()
    {
        console.log(this.value);
        // Do some things with this.value
    };

    $('#button').click(this.update);
};

浏览器在更新函数中抱怨 this.value 未定义。

我有最奇怪的内存泄漏,我不知道为什么.我有一个抽象类如下:

class ClassA
{
public:
    virtual ~ ClassA (){}
    virtual void notify(ClassB*) = 0;
    virtual void add(ClassB*) = 0;
}; 

class ClassC : public ClassA
{
public:
    void notify(ClassB*)
    { 
        //some cout statements
    }
    void add(ClassB*)
    { 
        //some cout statements
    }
};

int main()
{
    ClassA *f = new ClassC();
    delete f;
}

现在,当我编译代码并运行Valgrind时,它没有泄漏.但是,当我删除ClassA析构函数(或使其成为非虚拟)时,Valgrind将32字节报告为绝对丢失的内存.我不知道为什么会发生这种情况,因为我的析构函数什么也没做,而且没有成员变量.有任何想法吗？

编辑:我用U ++编译了Ubuntu 64位

我不确定这在C++中是否可行.我知道你可以将指向函数或静态成员函数的指针作为参数传递.我想要一个特定对象的函数指针,这样当函数执行时,它就在对象上完成.

class MyClass
{
   public:
      MyClass(int id){mId = id;}
      void execute(){cout<<mId<<endl;}
   private:
      int mId;
};


MyClass obj1(1);
MyClass obj2(2);

typedef (Executor)();
Executor ex1 = &obj1::execute();
Executor ex2 = &obj2::execute();

因此,当执行ex1时,应打印"1",如果执行ex2,则打印"2".这可能吗？

我有一个三层次的类:

template<class T> class Singleton;

class Base;

class Sub : public Base, public Singleton<Sub>;

我使用底层自动指针,这就是为什么Singleton是模板类而Sub将自身作为模板参数传递的原因.我正在开发Singleton和Base,公共API允许任何人添加自己的子类.我实际上想要一个像这样的真正的三层结构:

template<class T> class Singleton;

class Base : public Singleton<Base>;

class Sub : public Base;

这样外部开发人员就不必担心模板和复杂性.这个问题是我在Singleton中的实现现在每当我创建一个Sub实例时都会调用Base的构造函数(因为模板参数是Base).

我想知道这是否可以通过预处理器宏完成:

template<class T> class Singleton;

class Base : public Singleton<__CLASS_NAME__>;

class Sub : public Base;

哪个__CLASS_NAME__类名将由预处理器替换.从理论上讲,这应该是可能的,因为__PRETTY_FUNCTION__宏实际上返回了类名.问题是,无法执行字符串操作以从中删除函数名称__PRETTY_FUNCTION__.

关于如何实现这一点的任何想法,以便Sub类不知道继承自Singleton<template>类？