小编Ska*_*One的帖子

我有一个叫做类Writer的函数writeVector有这样的函数:

void Drawer::writeVector(vector<T> vec, bool index=true)
{
    for (unsigned int i = 0; i < vec.size(); i++) {
        if (index) {
            cout << i << "\t";
        }
        cout << vec[i] << "\n";
    }
}

我试图不要重复代码,同时仍然担心性能.在函数中,我正在if (index)对我的for-loop的每一轮进行检查,即使结果总是相同的.这反对"担心表现".

我可以通过将检查放在我的for-loop 之外来轻松避免这种情况.但是,我会得到大量重复的代码:

void Drawer::writeVector(...)
{
    if (index) {
        for (...) {
            cout << i << "\t" << vec[i] << "\n";
        }
    }
    else {
        for (...) {
            cout << vec[i] << "\n";
        }
    } …

告诉,不问原则,在这里,当我使用的getter和setter方法,人们告诉我,不使用它们往往是贴在我身上.该网站清楚地解释了我应该做什么,不应该做什么,但它并没有真正解释为什么我应该告诉,而不是问.我发现使用getter和setter效率更高,我可以用它们做更多的事情.

想象一下,一类Warrior具有属性health和armor:

class Warrior {
    unsigned int m_health;
    unsigned int m_armor;
};

现在有人用特殊的攻击攻击我的战士,使他的护甲降低5秒.使用setter's就像这样:

void Attacker::attack(Warrior *target)
{
    target->setHealth(target->getHealth() - m_damage);
    target->setArmor(target->getArmor() - 20);
    // wait 5 seconds
    target->setArmor(target->getArmor() + 20);
}

并告诉我们,不要问原则它会是这样的(如果我错了,请纠正我):

void Attacker::attack(Warrior *target)
{
    target->hurt(m_damage);
    target->reduceArmor(20);
    // wait 5 seconds
    target->increaseArmor(20);
}

现在第二个显然看起来更好,但我找不到这个的真正好处.你仍然需要相同数量的方法(increase/ decreasevs set/ get),你会失去询问你是否需要问的好处.例如,你如何将战士的健康状况设定为100？你怎么知道你是否应该使用heal或者hurt,你需要多少健康来治愈或受伤？

此外,我看到世界上一些最优秀的程序员正在使用setter和getter.大多数API使用它,并且它一直在std lib中使用:

for (i = 0; i < vector.size(); i++) {
    my_func(i);
} …

我知道如何编写和使用简单的类,我甚至知道继承如何工作以及如何使用它.但是,关于如何实际设计类层次结构,甚至如何设计简单类的指南数量非常有限？另外,我何时以及为什么要继承(或使用)一个类？

所以我不是在问我怎么样,我在问何时以及为什么.示例代码总是一种很好的学习方式,所以我很感激它们.此外,强调设计的进展,而不是简单地给出一个句子的时间和原因.

我主要使用C++,C#和Python编程,但我可能会理解大多数语言中的简单示例.

如果任何条款似乎混淆了,请随时编辑我的问题.我不是本地人,我不确定所有的话.

有两个简单的类；一个仅具有parent属性，一个同时具有parent和children属性。这意味着，一个既parent和children继承了一个只parent。

这是只有parent属性的类。之所以称呼它，是Child因为它只能是孩子，而不是父母。我将使用一种方法set_parent()使其更加清晰，但在实际代码中将使用setter。

class Child(object):

    def __init__(self, parent=None):
        self.__parent = None
        self.set_parent(parent)

    def set_parent(self, parent):
        # Remove self from old parent's children
        if self.__parent:
            self.__parent.remove_child(self)
        # Set new parent
        self.__parent = parent
        # Add self to new parent's children
        if self.__parent:
            self.__parent.add_child(self)

该代码很合理，并且似乎可以正常工作。这是如果Parent类看起来像这样简单：

class Parent(Child):

    def __init__(self, parent=None):
        super(Parent, self).__init__(parent)
        self.__children = []

    def add_child(self, child):
        if child not in self.__children: …

我正在使用WinAPI ReadProcessMemory()来阅读游戏中的一些"隐藏"信息.

我已经使用Cheat Engine来找出静态指针,但我不知道如何从中读取它们.Cheat Engine给了我一个这样的指针:"mygame.exe"+1C50

我是WinAPI的新手,如何转换"mygame.exe"+1C50为我可以阅读的地址ReadProcessMemory()？

编辑:我尝试简化问题,但我想我应该首先给出完整的代码.所以我在这里使用静态地址和多级指针,但我仍然坚持获取基地址或w/e.

这是我的作弊引擎地址的完整代码和图片:

#include <iostream>
#include <windows.h>
#include <tlhelp32.h>

using namespace std;

HANDLE GetProcessHandle(const char *procName);

int main()
{
    const char *procName = "prism3d.exe";
    HANDLE hProc = GetProcessHandle(procName);
    if (hProc) {

     /* This works if I use the dynamic address (f.e. 0x02C2C4DC),
        but it changes every time I restart the game.
        I need to use the static address (prism3d.exe+A1C) to get
        the dynamic address …

给定一个根目录，我需要从该根目录下的所有文件夹（以及其他文件夹内的文件夹）中导入所有文件。

我认为可以在的帮助下完成此操作os.walk()，但不知道在“遍历”文件后如何导入文件。

是否有捷径可寻？

我将如何在特定位置（从 0 开始）更新 OrderedDict 的值？所以：

od = OrderedDict(a=1, b=2, c=3)
od.update({'b': 4}) # a=1, b=4, c=3
od.update_values(2, 1)  # a=2, b=1, c=3

编码可以包含6个项目的库存可能看起来像这样:

class Inventory {
    private:
        Item[6] m_items;
};

另一方面,项目看起来像这样:

class Item {
    private:
        Inventory* m_parent;
};

但是,显然这两个班级都不能相互认识.一个解决方案是一个公共基类,但这两个类没有任何共同之处,它会导致更多问题,例如:我无法m_parent->addItem(this);从Item构造函数调用.

问题可能有点不清楚,所以我只提供代码:

class HitPoints {
    int m_current;
    int m_maximum;
    int m_regeneration;
};

所以基本上current意味着你现在拥有maximum的生命值,你可以获得的最大生命值,以及regeneration你每10秒获得多少马力.

现在的事情是; 并非我游戏中的每个生物都使用它regeneration来重新生成他们的hp,有些人随着时间的推移无法再生hp.

我是不是应该设置regeneration到0那些生物,或者我应该继承一个新的类:

class HitPoints {
    int m_current;
    int m_maximum;
};

class RegeneratingHitPoints : public HitPoints {
    int m_regeneration;
};

我认为这个小例子并不重要,但是利用我学到的知识,我应该继承一个新的课程.

我的问题是,一个属性真的重要吗？为了使它成为更通用的问题,创建新类有多严格？我有时可以"屈服"一点并使用旧班,即使我应该继承一个新班吗？

在Code :: Blocks上使用GCC编译器,我收到一个错误:

Segmentation fault (core dumped)

Process returned 139 (0x8B)
...

输入输入后询问.这是我的测试程序:

#include <iostream>
#include <string>

using namespace std;

string getInput(string &input, string prompt)
{
    cout << prompt;
    getline(cin, input);
}

int main()
{
    string input;
    getInput(input, "What's your name?\n>");
    cout << "Hello " << input << "!" << endl;
    return 0;
}

我做错了什么,参考参数使用不正确？

想象一下,有一个叫做Node可以容纳多个父母和多个孩子的班级:

class Node {
    public:
        Node();
        virtual void addParent(Node *parent);
        virtual void addChild(Node *child);
    private:
        vector<Node*> m_parents;
        vector<Node*> m_children;
};

问题是每次向节点添加父节点时,m_parents必须更新节点并且必须更新父节点m_children; 这会产生无限循环.

void Node::addParent(Node *parent)
{
    if (m_parents.lacks(parent)) { // supposing such method exists
        m_parents.push_back(parent);
    }
    parent->addChild(this);
}

void Node::addChild(Node *child)
{
    if (m_children.lacks(child)) {
        m_children.push_back(child);
    }
    child->addParent(this);
}

如你所见,这并不好.我设法通过添加四种方法来解决这个问题而不是两种方法,但感觉有点愚蠢.另外两种方法都是声明的private,protected因此不能被其他方法调用.这是原始addParent和新方法,称为rawAddChild:

void Node::addParent(Node *parent)
{
    if (m_parents.lacks(parent)) {
        m_parents.push_back(parent);
    }
    parent->rawAddChild(this);
}

void Node::rawAddChild(Node *child)
{
    if …