相关疑难解决方法(0)

我觉得这有点主观; 我不确定这个意见是否会一致(我已经看过很多代码片段,其中返回了引用).

根据对这个问题的评论我刚刚问过,关于初始化引用,返回引用可能是邪恶的,因为,[据我所知]它更容易错过删除它,这可能导致内存泄漏.

这让我很担心,因为我跟随了一些例子(除非我想象的事情)并且在相当多的地方做到了这一点......我误解了吗？这是邪恶的吗？如果是这样,那有多邪恶？

我觉得因为我的指针和引用混合在一起,再加上我是C++的新手,以及对什么时候使用的完全混淆,我的应用程序必须是内存泄漏地狱......

另外,我知道使用智能/共享指针通常被认为是避免内存泄漏的最佳方法.

我有一个类层次结构如下:

class BaseSession : public boost::enable_shared_from_this<BaseSession>
class DerivedSessionA : public BaseSession
class DerivedSessionB : public BaseSession

在派生类函数中,我经常调用这样的函数:

Func(boost::dynamic_pointer_cast<DerivedSessionA>(shared_from_this()));

由于我正在与shared_ptr管理会议,这工作正常.最近,我发现我shared_ptr对这种情况的使用不是最佳的.这是因为这些会话是单个对象,每个客户端维护一个套接字.如果重新连接套接字,则会话副本将成为僵尸.

作为解决方法,我开始通过shared_ptr引用传递而不是复制.这解决了僵尸问题.

理想情况下,我觉得我应该unique_ptr用来存储会话,然后将引用传递给其他函数.这打开了一大堆蠕虫.

如何将基类unique_ptr对象转换为派生类unique_ptr对象？unique_ptr以下行的版本是什么？

Func(boost::dynamic_pointer_cast<DerivedSessionA>(shared_from_this()));

我只想要一个会话对象的副本,其他一切都应该是参考.

我对"设计模式"相对较新,因为它们在正式意义上被提及.我很久没有成为一名专业人士,所以我对此很陌生.

我们有一个纯虚拟接口基类.这个接口类显然是提供了派生子进程应该做什么功能的定义.软件中的当前用法和情况决定了我们想要使用什么类型的派生子,因此我建议创建一个包装器,它将传达我们想要的派生子类型,并返回指向新派生对象的Base指针.据我所知,这个包装器是一个工厂.

好吧,我的一位同事在Base类中创建了一个静态函数来充当工厂.这有两个原因导致我麻烦.首先,它似乎打破了Base类的接口性质.我认为界面本身需要知道从中衍生出来的孩子,这对我来说是错误的.

其次,当我尝试在两个不同的Qt项目中重用Base类时,会导致更多问题.一个项目是我实现第一个(可能只是这个类的真正实现......虽然我想对其他两个具有几个不同派生类的特性使用相同的方法)派生类,第二个是实际最终将使用我的代码的应用程序.在我编写代码时,我的同事创建了一个派生类,作为真实应用程序的测试人员.这意味着我必须将他的标题和cpp文件添加到我的项目中,这似乎是错的,因为我在实现我的部分时甚至没有使用他的代码用于项目(但是当它完成时他将使用我的).

我是否正确认为工厂真的需要成为Base类的包装而不是作为工厂的Base？

最近我一直在尝试更好地理解在 C++ 中使用工厂模式。

我查阅了以下资源：

如何在C++中正确实现工厂方法模式

https://www.geeksforgeeks.org/design-patterns-set-2-factory-method/

https://sourcemaking.com/design_patterns/factory_method/cpp/1

https://www.codeproject.com/Articles/363338/Factory-Pattern-in-Cplusplus

https://www.bogotobogo.com/DesignPatterns/factorymethod.php

https://gist.github.com/pazdera/1099562

https://en.wikibooks.org/wiki/C%2B%2B_Programming/Code/Design_Patterns

在有人将其标记为“不是问题”之前，我确实有一些明确的问题，我稍后会讨论。但为了首先澄清我到目前为止的理解，我想从一个例子开始。这是我从上述链接中的信息中得到的最好的例子（最好的含义说明了工厂模式，但尽可能简单，因此该模式的初学者可以清楚地看到所涉及的问题）：

// FactoryPattern.cpp

#include <iostream>
#include <vector>

enum AnimalSpecies { dog, cat };


class Animal
{
public:
  virtual void makeSound() = 0;
};

class Dog : public Animal
{
public:
  void makeSound() { std::cout << "woof" << "\n\n"; }
};

class Cat : public Animal
{
public:
  void makeSound() { std::cout << "meow" << "\n\n"; }
};

class AnimalFactory
{
public:
  static Animal* makeAnimal(AnimalSpecies animalSpecies);
};

Animal* AnimalFactory::makeAnimal(AnimalSpecies animalSpecies) …

我必须在我的项目中实现多态。我有一个名为“帐户”的虚拟类。然后有 4 个子类：美元、欧元、英镑和瑞士法郎。我需要从这样的文本文件中读取当前余额：

USD 50
CHF 80
GBP 10
EUR 90

并根据货币创建一个子类。
每种货币都应该有自己的对象。稍后在程序中，我将实现货币兑换，将从文件中读取汇率。我不知道如何开始这些课程。我应该学习什么？

到目前为止我的代码：

class Account{
    std::string currency;
public:
    virtual void balance() = 0;
};

class currencyAcc: public Konto {
    std::string currency;
    float balance;
    walutowe(std::string currency,float balance) {
        this->currency= currency;
        this->balance= balance;
    }
    void AccBallance() {
        std::cout << balance<< std::endl;
    }
};

寻找一种避免大规模IF/ELSE并使用查找表将字符串解析为特定类来实例化的方法,这些方法都来自基类.这是可能的,如果是这样,怎么样？

typedef struct BaseClass
{
} BaseClass;

typedef struct DerivedClassOne : BaseClass
{
} DerivedClassOne;

typedef struct DerivedClassTwo : BaseClass
{
} DerivedClassTwo;

typedef struct
{
    const char *name;
    BaseClass class;
} LookupList;

LookupList list[] = {
    {"ClassOne", DerivedClassOne},
    {"ClassTwo", DerivedClassTwo}
};

BaseClass *InstantiateFromString(char *name)
{
    int i;
    for (i = 0; i < 2; i++)
    {
        if (!strcmp(name, list[i].name))
            return new list[i].class();
    }
}

int main (int argc, char *argv[])
{
    BaseClass *myObjectFromLookup = InstantiateFromString("ClassOne");
}

我是开发嵌入式系统的新手,并不习惯使用非常少的程序存储器(在这种情况下为16kB).我希望能够创建全局变量,数组和函数,我可以从程序中的任何位置访问,而只存在于内存中的一个位置.我目前的方法是使用静态类成员和方法,我可以通过简单地包含头文件(例如#include "spi.h")来使用.

对于我正在尝试做的事情,最好的方法是什么？

这是一个示例类.根据我的理解,_callback像call().cpp 这样的变量和函数定义只会出现在spi.o中,因此它们只会在内存中出现一次,但我可能会混淆.

spi.h中:

#ifndef SPI_H_
#define SPI_H_

#include "msp430g2553.h"

class SPI {
public:
    typedef void (*voidCallback)(void);

    static voidCallback _callback;
    static char largeArray[1000];
    static __interrupt void USCIA0TX_ISR();
    static void call();

    static void configure();
    static void transmitByte(unsigned char byte, voidCallback callback);
};

#endif /* SPI_H_ */

SPI.CPP:

#include "spi.h"

SPI::voidCallback SPI::_callback = 0;
char SPI::largeArray[] = /* data */ ;

void SPI::configure() {
    UCA0MCTL = 0;
    UCA0CTL1 &= ~UCSWRST; …

我需要一种基于作为std :: string传递的类名来实例化对象的方法.这项目前正在发挥作用,但需要进行概括:

void* create(std::string name) {
    if(name == "classOne") return new ClassOne();
    else if(name == "classTwo") return new ClassTwo();
    /* ... */
}

我没有的东西:

• 控制要实例化的类:可能是30个派对类.不能对这些类进行任何更改(即基本祖先,多态创建者方法等...)
• 全班名单列表:以后可以添加更多类,不应该对此工厂进行更改.
• 要实例化的类周围的包装:由于前两点.

还有别的什么.

最佳用例场景将是:

int main() {
    void *obj = create("classTree"); // create object based on the string name
    /* ... */
    // once we know by context which specific class we are dealing with
    ClassTree *ct = (ClassTree*)obj; // cast to appropiate class
    std::cout << ct->getSomeText() << std::endl; // use object
} …

考虑类之间的以下关系:

int main(int, char**) { | class Window {      | class Layout { | class Box {
    /* Use argc/argv */ |     Layout layout;  |     Box box;   |     int height,
    Window window;      |                     |                |         max_width;
}                       |     bool print_fps; | public:        |
                        |                     |     Layout();  | public:
                        | public:             | };             |     Box (int,int);
                        |     Window ();      |                | };
                        | };                  |                |

^{我为了简单起见构建了这个结构,实际上还有更多的类.}
在main()我获取一些应用程序参数(通过配置文件,数据库,CLI参数).现在我想将这些值传递给所需的对象.

我的问题:哪些是最好/最优雅的方法来"破墙",以便我可以"抛出"配置和谁需要它"抓住"它？

最初,我"打开了一些门",并为 …

我有多个共享一个公共基类的类,如下所示:

class Base {};

class DerivedA : public Base {};
class DerivedB : public Base {};
class DerivedC : public Base {};

现在,我需要知道在运行时(基于输入)实例化这些派生类中的哪一个.例如,如果是输入"DerivedA",我需要创建一个DerivedA对象.输入不一定是字符串,也可以是整数 - 关键是有某种键,我需要一个值来匹配键.

但问题是,如何实例化该类？C++没有像C#或Java那样的内置反射.我发现一个常见的解决方案是使用这样的工厂方法:

Base* create(const std::string& name) {
    if(name == "DerivedA") return new DerivedA();
    if(name == "DerivedB") return new DerivedB();
    if(name == "DerivedC") return new DerivedC();
}

如果只有几个类,这就足够了,但如果有几十个或几百个派生类,那就变得很麻烦并且可能很慢.我可以很容易地自动化地图创建过程来生成一个std::map<std::string, ***>,但我不知道要存储什么作为值.AFAIK,不允许指向构造函数的指针.同样,如果我使用这个地图做工厂,我仍然需要为每种类型编写一个工厂方法,使其比上面的例子更麻烦.

什么是处理这个问题的有效方法,特别是当有很多派生类时？

我正在进行模拟,它需要创建多个相似的模型.我的想法是有一个名为Model的类,并使用静态工厂方法来构建模型.例如; Model :: createTriangle或Model :: createFromFile.我从之前的Java代码中获取了这个想法,并且正在寻找在C++中实现它的方法.

这是我到目前为止提出的:

#include <iostream>

class Object {
    int id;

public:
    void print() { std::cout << id << std::endl; }

    static Object &createWithID(int id) {
        Object *obj = new Object();

        obj->id = id;

        return *obj; 
    }
};

int main() {
    Object obj = Object::createWithID(3);

    obj.print();

    return 0;
}

关于这个的一些问题:

• 这是一种被接受且干净的制作物品的方式吗？
• 返回的引用是否始终确保正确删除对象？
• 没有指针有没有办法做到这一点？