※设计模式※→☆创建型模式☆============Complex Factory模式（三）

最新推荐文章于 2024-04-27 21:55:24 发布
最新推荐文章于 2024-04-27 21:55:24 发布
阅读量5.2w 收藏 1
点赞数 1
分类专栏： 设计模式 DesignPattern(设计模式) 文章标签： c++ C++ Complex Factory Design Pattern design pattern Design pattern 复杂工厂模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaoting451292510/article/details/8290809
版权

模式概述

       一般情况 下，我们为了提高内聚和松耦合，经常会使用多态来处理一些问题。抽象出一些类的公共接口作为抽象基类或者接口。这样的话，我们将会面临一个挑战。在每次使用子类的时候，我们不得不经常使用base* = New XXX （这也无可厚非，但当系统复杂后，我们可能将无法维护子类的创建），最终我们在程序的扩展和维护成本上的开销将变得越来越大，越来越难。
       我们知道经常“某个对象”由于需求的变化，对象的具体实现面临着剧烈的变化。为了应对这种变化我们抽象出它比较稳定的接口，隔离出“这个易变对象”的变化，从而保持系统中“其它依赖该对象的对象”不随着需求的改变而改变，这就是我们经常谈的Factory模式了。
       简单Simple Factory模式可以实现 ”定义创建对象的接口，并封装对象的创建“。
             Simple Factory模式见：
 http://blog.csdn.net/xiaoting451292510/article/details/8289608

       然而，Simple Factory模式只解决了一个问题 "对象的创建封装"，这个并不是Factory模式的真正意义所在。Factory模式的真正意义或者说他的威力是 ”将具体化类的工作延迟到了类中“，因此实际上我们一般经常使用的是ComplexFactory模式。

 

Complex Factory模式由以下角色组成

  • 抽象工厂（Factory）角色：工厂方法模式的核心，任何在模式中创建对象的工厂类必须实现这个接口。实际工作中，这个角色也常常使用抽象类实现。(或者使用接口+抽象类更好的封装)
  • 具体工厂（ConcreteFactory）角色：实现了抽象工厂接口的具体类，含有与业务密切相关的逻辑，并且受到使用者的调用以创建产品类。
  • 抽象（Product）产品：工厂方法模式所创建的对象的抽象类，也就是所有产品类的共同父类或共同拥有的接口。实际工作中，这个角色也常常使用抽象类实现。(或者使用接口+抽象类更好的封装,如上就运用抽象类+接口+继承)
  • 具体（ConcreteProduct）产品：实现了实现了抽象运算所声明的接口，工厂方法模式所创建的每一个对象都是某个具体产品角色的实例。

模式结构

        Complex Factory模式结构如下：


                            
        
        这里我把ComplexFactory类使用Singleton模式处理了，因为确确实实我只需要一个这样的工厂，而不是需要多个。
                Singleton模式见：
                             http://blog.csdn.net/xiaoting451292510/article/details/8285710
       惯例，我个人习惯是喜欢把拷贝构造函数和赋值函数私有化，并不对其进行实现。以避免一些不必要的麻烦，如果确实是需要使用拷贝构造函数和赋值函数时，再进行一些相关具体情况的处理。

 

 

模式讨论

       Complex Factory模式将对象的创建封装了，例如：我们在游戏开发中，经常碰见有N个职业。战士、法师、牧师等等。这里我们可以通过Complex Factory模式来实现。然而其实我们使用Complex  Factory模式并不十分完美。上述是继承方法来实现创建各个职业的类型。如果我们又新增加了一个职业盗贼。我们就不得不新继承一个子类了。这样我们不得不以新建一个类作为代价。


       Complex Factory模式也只能解决在一类类对象的创建（即这一类类，有着共同的基类）。如果要为不同类的类提供一个对象创建的接口。我们可以考虑使用AbstractFactory模式。
                Abstract Factory模式见：
                         http://blog.csdn.net/xiaoting451292510/article/details/8290814


最后，无论模式多么优越，我们也需要根据实际的具体情况而慎重考虑。

 

 

模式实现

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
以后的笔记潇汀会尽量详细讲解一些相关知识的，希望大家继续关注我的博客。
本节笔记到这里就结束了。

潇汀一有时间就会把自己的学习心得，觉得比较好的知识点写出来和大家一起分享。
编程开发的路很长很长，非常希望能和大家一起交流，共同学习，共同进步。
如果文章中有什么疏漏的地方，也请大家指正。也希望大家可以多留言来和我探讨编程相关的问题。
最后，谢谢你们一直的支持~~~


       C++完整个代码示例（代码在VS2005下测试可运行）
代码及相关下载地址：
              http://download.csdn.net/detail/xiaoting451292510/4904578


DesignPattern.cpp 

// DesignPattern.cpp : Defines the entry point for the console application.
//




#include "stdafx.h"




#ifndef CXX_DESIGNPATTERN_SINGLETON_H
#include "DESIGNPATTERN_Singleton.h"
#endif




#ifndef CXX_PROFESSION_H
#include "Profession.h"
#endif




#ifndef CXX_DESIGNPATTERN_SIMPLEFACTORY_H
#include "DESIGNPATTERN_SimpleFactory.h"
#endif




#ifndef CXX_DESIGNPATTERN_COMPLEXFACTORY_H
#include "DESIGNPATTERN_ComplexFactory.h"
#endif








int _tmain(int argc, _TCHAR* argv[])
{
#if DEBG_TEST_SINGLETON
Singleton* pSingletonA = NULL;
Singleton* pSingletonB =  NULL;


pSingletonA = Singleton::Instance();
pSingletonB = Singleton::Instance();




Singleton::Destroy();
Singleton::Destroy();
#endif




#if DEBG_TEST_SIMPLEFACTORY
Profession* pProfession[3] =  {0};




for (int i=0; i<3; i++) {
pProfession[i] = SimpleFactory::Instance()->CreateProfession(i);
}
for (int i=0; i<3; i++) {
if (NULL != pProfession[i]) {
delete pProfession[i];
pProfession[i] = NULL;
}
}


#endif




#if DEBG_TEST_COMPLEXFACTORY
ComplexFactory* pWarriorFactory = WarriorFactory::Instance();
ComplexFactory* pMasterFactory = MasterFactory::Instance();
Profession* pWarrior = pWarriorFactory->CreateProfession();
Profession* pMaster = pMasterFactory->CreateProfession();




if (NULL != pWarrior) {
delete pWarrior;
pWarrior = NULL;
}
if (NULL != pMaster) {
delete pMaster;
pMaster = NULL;
}
#endif












return 0;
}





DESIGNPATTERN_ComplexFactory.h 

/**
  @file     DESIGNPATTERN_ComplexFactory.h
  @brief     1. Define an interface for creating an object, and the package object is created
                2. The work of the specific class of delay to sub-class
  @author   arvin
  @version 1.0   2012/12/14
 */


#ifndef CXX_DESIGNPATTERN_COMPLEXFACTORY_H
#define CXX_DESIGNPATTERN_COMPLEXFACTORY_H


class Profession;


class ComplexFactory
{
public:
/**
* Destruction
*
* @param VOID
* @return 
*/
virtual ~ComplexFactory() = 0;


/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note
*/
virtual Profession* CreateProfession() = 0;
protected:
/**
* Construction
*
* @param VOID
* @return 
*/
ComplexFactory();


private:


/**
* Copy Construction
*
* @param const ComplexFactory& cComplexFactory
* @return 
*/
ComplexFactory(const ComplexFactory& cComplexFactory);


/**
* Assignment
*
* @param const ComplexFactory& cComplexFactory
* @return ComplexFactory&
*/
ComplexFactory& operator=(const ComplexFactory& cComplexFactory);


public:
protected:
private:
};




class WarriorFactory : public ComplexFactory
{
public:
/**
* Destruction
*
* @param VOID
* @return 
*/
virtual ~WarriorFactory();


/**
* Instance
*
* @param VOID
* @return ComplexFactory*
* @note singleton
*/
static ComplexFactory* Instance();

/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
static VOID Destroy();


/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note create Warrior
*/
Profession* CreateProfession();
protected:
private:
/**
* Construction
*
* @param VOID
* @return 
*/
WarriorFactory();


/**
* Copy Construction
*
* @param const WarriorFactory& cWarriorFactory
* @return 
*/
WarriorFactory(const WarriorFactory& cWarriorFactory);


/**
* Assignment
*
* @param const WarriorFactory& cWarriorFactory
* @return WarriorFactory&
*/
WarriorFactory& operator=(const WarriorFactory& cWarriorFactory);


public:
protected:
private:
static WarriorFactory* m_pInstance;
};


class MasterFactory : public ComplexFactory
{
public:
/**
* Destruction
*
* @param VOID
* @return 
*/
~MasterFactory();


/**
* Instance
*
* @param VOID
* @return ComplexFactory*
* @note singleton
*/
static ComplexFactory* Instance();

/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
static VOID Destroy();


/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note create Master
*/
Profession* CreateProfession();
protected:
private:
/**
* Construction
*
* @param VOID
* @return 
*/
MasterFactory();


/**
* Copy Construction
*
* @param const MasterFactory& cMasterFactory
* @return 
*/
MasterFactory(const MasterFactory& cMasterFactory);


/**
* Assignment
*
* @param const MasterFactory& cMasterFactory
* @return MasterFactory&
*/
MasterFactory& operator=(const MasterFactory& cMasterFactory);


public:
protected:
private:
static MasterFactory* m_pInstance;
};
#endif /* >>CXX_DESIGNPATTERN_COMPLEXFACTORY_H<< */
/* EOF */


DESIGNPATTERN_ComplexFactory.cpp 

/**
  @file     DESIGNPATTERN_ComplexFactory.h
  @brief     1. Define an interface for creating an object, and the package object is created
                2. The work of the specific class of delay to sub-class
  @author   arvin
  @version 1.0   2012/12/14
 */
#include "stdafx.h"




#ifndef CXX_DESIGNPATTERN_COMPLEXFACTORY_H
#include "DESIGNPATTERN_ComplexFactory.h"
#endif




#ifndef CXX_PROFESSION_H
#include "Profession.h"
#endif




/**
* Construction
*
* @param VOID
* @return 
*/
ComplexFactory::ComplexFactory()
{




}




/**
* Destruction
*
* @param VOID
* @return 
*/
ComplexFactory::~ComplexFactory()
{




}








/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note
*/
Profession* 
ComplexFactory::CreateProfession()
{
//system error log
cerr<<"got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;




return NULL;
}












WarriorFactory* WarriorFactory::m_pInstance = NULL;




/**
* Construction
*
* @param VOID
* @return 
*/
WarriorFactory::WarriorFactory()
{




}




/**
* Destruction
*
* @param VOID
* @return 
*/
WarriorFactory::~WarriorFactory()
{




}




/**
* Instance
*
* @param VOID
* @return WarriorFactory*
* @note WarriorFactory
*/
WarriorFactory* 
WarriorFactory::Instance()
{
if (NULL == m_pInstance) {
m_pInstance = new WarriorFactory;
}
return m_pInstance;
}








/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
VOID 
WarriorFactory::Destroy()
{
if (NULL != m_pInstance) {
delete m_pInstance;
m_pInstance = NULL;
}
}




/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note create Warrior
*/
Profession* 
WarriorFactory::CreateProfession()
{
return new Warrior;
}




MasterFactory* MasterFactory::m_pInstance = NULL;








/**
* Construction
*
* @param VOID
* @return 
*/
MasterFactory::MasterFactory()
{




}




/**
* Destruction
*
* @param VOID
* @return 
*/
MasterFactory::~MasterFactory()
{




}




/**
* Instance
*
* @param VOID
* @return MasterFactory*
* @note MasterFactory
*/
MasterFactory* 
MasterFactory::Instance()
{
if (NULL == m_pInstance) {
m_pInstance = new MasterFactory;
}
return m_pInstance;
}








/**
* Destroy
*
* @param VOID
* @return VOID
* @note singleton
*/
VOID 
MasterFactory::Destroy()
{
if (NULL != m_pInstance) {
delete m_pInstance;
m_pInstance = NULL;
}
}




/**
* Create Profession
*
* @param VOID
* @return Profession* 
* @note create Master
*/
Profession* 
MasterFactory::CreateProfession()
{
return new Master;
}




/* EOF */






Profession.h 

/**
  @file     Profession.h 
  @brief     all kinds of Profession
  @author   arvin
  @version 1.0   2012/12/13
 */




#ifndef CXX_PROFESSION_H
#define CXX_PROFESSION_H




class Profession
{
public:
/**
* Construction
*
* @param VOID
* @return 
*/
Profession();




/**
* Destruction
*
* @param VOID
* @return 
*/
    virtual ~Profession() = 0;




/**
* Operation
*
* @param VOID
* @return 
*/
virtual VOID Operation() = 0;




protected:
private:


/**
* Copy Construction
*
* @param const Profession& cSimpleFactory
* @return 
*/
Profession(const Profession& cSimpleFactory);




/**
* Assignment
*
* @param const Profession& cSimpleFactory
* @return Profession&
*/
Profession& operator=(const Profession& cSimpleFactory);




public:
protected:
private:
};




class Warrior : public Profession
{
public:
/**
* Construction
*
* @param VOID
* @return 
*/
Warrior();




/**
* Destruction
*
* @param VOID
* @return 
*/
virtual ~Warrior();




/**
* Operation
*
* @param VOID
* @return 
*/
virtual VOID Operation();




protected:
private:


/**
* Copy Construction
*
* @param const Warrior& cSimpleFactory
* @return 
*/
Warrior(const Warrior& cSimpleFactory);




/**
* Assignment
*
* @param const Warrior& cSimpleFactory
* @return Warrior&
*/
Warrior& operator=(const Warrior& cSimpleFactory);




public:
protected:
private:
};




class Master : public Profession
{
public:
/**
* Construction
*
* @param VOID
* @return 
*/
Master();




/**
* Destruction
*
* @param VOID
* @return 
*/
virtual ~Master();




/**
* Operation
*
* @param VOID
* @return 
*/
virtual VOID Operation();




protected:
private:


/**
* Copy Construction
*
* @param const Master& cSimpleFactory
* @return 
*/
Master(const Master& cSimpleFactory);




/**
* Assignment
*
* @param const Master& cSimpleFactory
* @return Master&
*/
Master& operator=(const Master& cSimpleFactory);




public:
protected:
private:
};




#endif /* >>CXX_DESIGNPATTERN_SINGLETON_H<< */
/* EOF */





Profession.cpp 
 

/**
  @file     Profession.h 
  @brief     all kinds of Profession
  @author   arvin
  @version 1.0   2012/12/13
 */




#include "stdafx.h"




#ifndef CXX_PROFESSION_H
#include "Profession.h"
#endif




/**
* Construction
*
* @param VOID
* @return 
*/
Profession::Profession()
{
cout<<"Construction Profession"<<endl;
}




/**
* Destruction
*
* @param VOID
* @return 
*/
Profession::~Profession()
{
cout<<"Destruction Profession"<<endl;
}




/**
* Operation
*
* @param VOID
* @return 
*/
VOID 
Profession::Operation()
{
//system error log
cerr<<"got called from thread "<</*ThreadID*/"at: "/**gettimeofday()*/<<endl;
}




/**
* Construction
*
* @param VOID
* @return 
*/
Warrior::Warrior()
{
cout<<"Construction Warrior"<<endl;
}




/**
* Destruction
*
* @param VOID
* @return 
*/
Warrior::~Warrior()
{
cout<<"Destruction Warrior"<<endl;
}




/**
* Operation
*
* @param VOID
* @return 
*/
VOID 
Warrior::Operation()
{




}








/**
* Construction
*
* @param VOID
* @return 
*/
Master::Master()
{
cout<<"Construction Master"<<endl;
}




/**
* Destruction
*
* @param VOID
* @return 
*/
Master::~Master()
{
cout<<"Destruction Master"<<endl;
}




/**
* Operation
*
* @param VOID
* @return 
*/
VOID 
Master::Operation()
{




}




/* EOF */


 

 

 

arvin_xiaoting
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【设计模式】（八）–创建型模式–建造者模式
01-21
【设计模式】（八）–创建型模式–建造者模式 建造者模式【设计模式】（八）–创建型模式–建造者模式建造者模式定义构造者模式的优点构造者模式的使用场景构造者模式和工厂模式区别构造者模式简单实现 建造者模式...
CeXI-NdXIII离子n=5complex 能级与跃迁谱线波长理论计算
03-14
CeXI-NdXIII离子n=5complex 能级与跃迁谱线波长理论计算，丁凯，胡智向，本文运用HFR方法对IVI-NdXIII离子5s2，5p2，5s5d，5s5p组态能级结构进行了理论计算，对CdI等电子序列离子n=5complex 组态的能级结构和组态...
三、抽象工厂(Abstract Factory)模式
weixin_30650039的博客
01-02 127
抽象工厂也是类的创建模式。抽象工厂面对的是多个产品等级结构的系统设计。而工厂方法模式针对的是一个产品等级结构。 该模式在增加新的产品族时：只需要在每个产品等级下面增加一个具体的产品角色即可。只需要对应的增加新的具体工厂类即可，是满足“开闭”原则的。 当模式在增加新的产品等级时：就需要修改工厂角色的接口，为其增加一个新的工厂方法。因此所有的工厂角色都需要修改，需要为每个工厂类都增加一个新的...
简单易懂23种设计模式——享元模式【含C++代码实例】
机器人梦想家 Bing
09-29 1444
在做面向对象的软件开发时我们往往想达到更高的代码可复用性和更合理的软件颗粒度。 　　根据《设计模式——可复用面向对象软件的基础》所说：“你必须找到相关的对象，以适当的颗粒度将他们回归类，再定义类的接口和继承层次，建立对象之间的基本关系。你的设计应该对手头的问题有针对性，同时对将来的问题和需求也要有足够的通用性。” 　　内行的设计者知道：不是解决任何问题都要从头做起。他们更愿意复用以...
※设计模式※→☆创建型模式☆============Abstract Factory模式（四）
潇汀
12-13 5万+
模式概述 一般情况 下，我们为了高内聚和松耦合，经常会使用多态来处理一些问题。抽象出一些类的公共接口作为抽象基类或者接口。这样的话，我们将会面临一个挑战。在每次使用子类的时候，我们不得不经常使用base* = New XXX （这也无可厚非，但当系统复杂后，我们可能将无法维护子类的创建），最终我们在程序的扩展和维护成本上的开销将变得越来越大，越来越难。 我们知道经常“...
※设计模式※→☆创建型模式☆============Prototype模式（六）
潇汀
01-07 5万+
模式概述 Prototype模式即原型模式，提供一个已经存在的对象进行新对象创建的接口，一般情况下都是使用Clone接口。 此模式非常简单，简单的说就是复制多个当前对象供使用。Prototype模式允许一个对象再创建另外一个可定制的对象，根本无需知道任何如何创建的细节,工作原理是:通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷...
※设计模式※→☆创建型模式☆============Builder模式（五）
潇汀
12-19 5万+
模式概述 Builder模式相当容易让人误解，并走向误区。相信各位也同我一样对Builder模式有着许许多多的疑惑，非常容易与abstract factory模式和Template模式混淆，这些我将在模式实现中仔细同大家一起研究讨论。鉴于Builder模式的误解性比较高，本人也是研究和思考很多人写的一些文章，当然本人此次的文章也仅仅只供大家的参考。开篇前先一起参考下几篇有关...
设计模式概述 以及 23种设计模式的介绍
热门推荐
数据知道的博客
05-24 9万+
设计模式概述（Design pattern）： 设计模式：代表了最佳的实践，通常被有经验的面向对象的软件开发人员所采用。设计模式是软件开发人员在软件开发过程中面临的一般问题的解决方案。这些解决方案是众多软件开发人员经过相当长的一段时间的试验和错误总结出来的。 设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了重用代码、让代码更容易被他人理解、保证代码可......
23种设计模式（C++实现）
kongshihaoyue的博客
04-18 1191
文章实现23种设计模式并配有介绍。
揭示C++设计模式中的实现结构及应用——结构型设计模式
最新发布
一枚菜鸡
04-27 821
结构型模式（Structural Pattern）描述如何将类或者对象结合在一起形成更大的结构，就像搭积木，可以通过 简单积木的组合形成复杂的、功能更为强大的结构。
Java中的设计模式在代码重构中的应用
编程小弟的博客
04-21 1245
设计模式是在软件开发中经常使用的一种经验总结，用于解决在特定上下文中重复出现的问题。在代码重构中，设计模式可以帮助我们改善代码的结构、可读性和可维护性。下面是几个常见的设计模式及其在代码重构中的应用。
设计模式 创建型模式 Complex Factory模式(复杂工厂)
12-19
Complex Factory模式 1 定义创建对象的接口，并封装对象的创建 2 将具体化类的工作延迟到了类中 一般情况下，我们为了提高内聚和松耦合，经常会使用多态来处理一些问题。抽象出一些类的公共接口作为抽象基类或者...
运算符重载 Complex类 ，复数运算，+ += - -= * <<
02-26
运算符重载 Complex类 ，复数运算，+ += - -= * 请多指教
※设计模式※→☆创建型模式☆============Singleton模式（一）
潇汀
12-12 3万+
模式概述 个人认为 Singleton模式是所有设计试中最简单，最常见，也是最容易实现的，因此，设计模式就先从Singleton模式开始说起吧！对于开发人员来说也是最应该熟悉和把握的模式。因此，此模式在招聘的现场上出现的概率是极高的。面试官为考察面试者对设计 的基本了解和掌握，经常会问 “设计模式中的单键模式用来解决什么问题？如何实现？” Singlet...
※设计模式※→☆创建型模式☆============Simple Factory模式（二）
潇汀
12-13 3万+
模式概述 一般情况 下，我们为了提高内聚和松耦合，经常会使用多态来处理一些问题。抽象出一些类的公共接口作为抽象基类或者接口。这样的话，我们将会面临一个挑战。在每次使用子类的时候，我们不得不经常使用base* = New XXX（这也无可厚非，但当系统复杂后，我们可能将无法维护子类的创建），最终我们在程序的扩展和维护成本上的开销将变得越来越大，越来越难。 我们知道...
※设计模式※→☆结构型模式☆============Bridge模式（七）
潇汀
02-18 3万+
模式概述 Bridge模式应该是设计模式中比较复杂和理解性较难的模式了，当然，此模式是也是面向对象开发和面向对象设计中占有相当重要的席位，因此我们会有OO开发中经常使用到。在Bridge模式中我们使用组合(委托)和方式将抽象和实现进行解耦合，这样可以使抽象和实现都独立化。这说这里，也许我们想起了Build模式。没错，确实是这样的，Build模式也是使用组合(委托)的方式实现了"将...
※设计模式※→☆结构型模式☆============Adapter模式（八）
潇汀
12-16 3万+
模式概述 Adapter模式将一个接口转换成客户希望的另一个接口，使接口不兼容的那些类可以一起工作，其别名为包装器(Wrapper)。应用于某项工作购买了一个第三方的库来加快开发。我们在应用程序中已经设计好了接口，与这个第三方提供的接口不一致，为了使得这些接口不兼容的类（不能在一起工作）可以在一起工作了，Adapter模式提供了将一个类（第三方库）的接口转化为客户（购买使用者）希望...
※设计模式※→☆结构型模式☆============Composite模式（十）
潇汀
12-24 1万+
模式概述 在开发中，我们经常可能要递归构建树状的组合结构，如类似以下结构，Composite模式则提供了很好的解决方案。当然也可以直接使用三方库tree，官方网址http://tree.phi-sci.com/。可作为STL的扩展库使用。 最经典的例子莫过于计算机文件系统了。在文件系统中有文件夹的概念，文件夹里面既可以放入文件也可以放入文件夹，但是文件中却不能放入任何东西。文件夹和文件...
dtype = complex
05-25
dtype = complex 是用于指定数组或张量的数据类型，表示数组或张量中的元素是复数。在使用该数据类型时，数组或张量中的每个元素都将是一个复数，由实部和虚部组成。例如，一个形状为 (2, 3) 的 dtype = complex ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值