C++ Object实体类
*暂未完成,因为无尽BUG滚滚来。
好长时间没写完,一是能力不够,二是我还得给老板写WEB的代码。可是我不会WEB!js和PHP简直就是世界上最好的语言,因为它们能够让人更快地进入极乐世界。
让我写一个gm后台,他说好不好看无所谓,能用就行。于是,我就写了一个根据JSON数据自动生成页面的代码……哈哈,平均15分钟完成一个功能,简直不要太爽。懒人自然有懒办法。当然,之前写工具花费了大量时间。
回家还要玩激战2刷每日,还挺忙的……
好吧,我已经没有力气给自己吐槽了。。。所以,直接上代码吧,不废话了。
以下代码为C++代码。
简直通俗易懂。
接下来(预计实现):
1.结构改造:在代码中定义一个对象的属性关联以及拥有属性是不太方便的,应该将这种关系和数据放置于配置表中。甚至是接下来的事件类和故事(story)类也应当如此。
1.1 首先,需要定义基本动作,
1.2 定义动作指令
1.3 需要一个虚拟机,基于栈的或者是基于寄存器的。还是栈虚拟机实现更简单一点,尽管效率稍差。
1.3.1 图形界面或者脚本程序。前者对于设计师来说更加友好。
1.4 协议。应当将虚拟机生成的字节码翻译成数据发送给主程序处理。
1.5 存储。生成的字节码应该被存储在配置表或者数据库中。
1.6 处理。主程序应该有足够通用、健壮和效率的算法来处理这个字节码。
看来这是一个大工程。
2.集中测试(2018.11.1 19:25)
LunaObject.h
#pragma once #include "stdinc.h"
#include "Location.h"
#include "QualitiesManager.h"
#include "QualInc.h" namespace Lunacia
{
class ObjectInfo final
{
private:
//info name: value pointer
std::unordered_map<std::string, void*> _infos;
std::unordered_map<std::string, std::function<void(const std::string&)>> _destory; public:
ObjectInfo();
ObjectInfo(std::unordered_map<std::string, void*>& infos);
~ObjectInfo(); public:
template<typename T>
T& Get(const std::string& name)
{
if (!IsExist(name))
{
ErrorThrow("The data is not exist what name is " + name);
} return *(static_cast<T*>(_infos.find(name)->second));
} template<typename T>
void Set(const std::string& name, T& val)
{
auto itFound = _infos.find(name);
void* pFound = nullptr;
if (itFound == _infos.end())
{
Add(name, val);
return;
} pFound = itFound->second;
T* pVal = static_cast<T*>(pFound);
*pVal = val;
} template<typename T>
void Replace(const std::string& name, const T& value)
{
Delete<T>(name);
Add(name, value);
} template<typename T>
bool Add(const std::string& name, const T& value)
{
T* pValue = new T();
*pValue = value; std::function<void(const std::string&)> destoryFunc = [this](const std::string& n)->void
{
this->Delete<T>(n);
}; _destory.insert(std::make_pair(name, destoryFunc));
return _infos.insert(std::make_pair(name, static_cast<void*>(pValue))).second;
} template<typename T>
bool Delete(const std::string& name)
{
auto itFound = _infos.find(name);
if (itFound == _infos.end())
{
return false;
}
void* pVal = itFound->second; T* pDel = static_cast<T*>(pVal);
delete pDel;
pVal = nullptr; _destory.erase(name);
return _infos.erase(name) == ;
} bool IsExist(const std::string& name) const;
}; //////////LunaObject//////////
class LunaObject
{
public:
LunaObject();
virtual ~LunaObject(); public:
virtual void QualitiesCorrelation() = ; public:
virtual ObjectInfo& Info();
virtual void Destory(); #ifdef __Debug
public:
#else
protected:
#endif // __Debug
ObjectInfo m_info;
QualitiesManager m_qualManager;
}; ///////////NullObject///////////
class NullObject: public LunaObject
{
private:
static NullObject* _instance; private:
NullObject(); public:
friend class ObjectManager;
void Destory() override;
ObjectInfo& Info() override; static NullObject* const GetInstance(); private:
void QualitiesCorrelation() override;
}; extern NullObject NULL_OBJECT;
extern NullObject* const NULLPTR_OBJECT;
}; //#define ADDOBJ(className) g_ObjectManager.AddObject(#className,new className)
LunaObject.cpp
#include "LunaObject.h" namespace Lunacia
{
LunaObject::LunaObject()
{
} LunaObject::~LunaObject()
{
Destory();
} ObjectInfo & LunaObject::Info()
{
return m_info;
} void LunaObject::Destory()
{
m_qualManager.Clear();
} /**
* @class: NullObject.
* @lazy initializate: false.
* @thread safe: true.
*
*/
NullObject* NullObject::_instance = new NullObject(); static NullObject* const NULLPTR_OBJECT = NullObject::GetInstance();
static NullObject NULL_OBJECT = *NULLPTR_OBJECT; NullObject::NullObject()
{
} NullObject* const NullObject::GetInstance()
{
return _instance;
} void NullObject::Destory()
{
ErrorThrow("Destory Function: It is null object!");
} ObjectInfo & NullObject::Info()
{
ErrorThrow("GetObjectInfo Function: It is null object!");
return m_info;
} void NullObject::QualitiesCorrelation()
{
ErrorThrow("QualitiesCorrelation Function: It is null object!");
} //////////////ObjectInfo//////////////
ObjectInfo::ObjectInfo()
{
} ObjectInfo::ObjectInfo(std::unordered_map<std::string, void*>& infos):
_infos(infos)
{
} ObjectInfo::~ObjectInfo()
{
std::unordered_map<std::string, void*>::iterator it;
while (!_infos.empty())
{
it = _infos.begin(); const std::string& name = it->first;
(_destory[name])(name);
} _infos.clear();
_destory.clear();
} bool ObjectInfo::IsExist(const std::string & name) const
{
if (_infos.find(name) == _infos.end())
{
return false;
}
return true;
}
};
ObjectManager.h
#pragma once #include "LunaObject.h"
#include "UniqueID.h" namespace Lunacia
{
class ObjectManager final
{
public:
ObjectManager();
~ObjectManager(); void Clear(); public:
int Add(LunaObject * obj); template<class T, typename std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type * = nullptr >
int Add(); template<class T, typename std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type * = nullptr >
LunaObject* Create(); void Remove(int id);
LunaObject*const Find(int id);
const LunaObject*const Find(int id) const; private:
std::map<int, LunaObject*> m_objects;
};
/////////////// template<class T, typename std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type *>
inline int ObjectManager::Add()
{
LunaObject* pObj = Create<T>();
return Add(pObj);
} template<class T, typename std::enable_if <std::is_base_of<LunaObject, T>::value, T> ::type *>
inline LunaObject * ObjectManager::Create()
{
return new T();
} };
ObjectManager.cpp
#include "ObjectManager.h" namespace Lunacia
{
ObjectManager::ObjectManager()
{
} ObjectManager::~ObjectManager()
{
} void ObjectManager::Clear()
{
for (auto& itEach : m_objects)
{
LunaObject* lo = itEach.second;
lo->Destory(); delete lo;
lo = NULLPTR_OBJECT;
}
} int ObjectManager::Add(LunaObject * obj)
{
int id = static_cast<int>(UniqueID::Get());
obj->Info().Set("id", id); return m_objects.insert(std::make_pair(id, obj)).second ? id : -;
} void ObjectManager::Remove(int id)
{
auto itFound = m_objects.find(id);
if (itFound != m_objects.end())
{
return;
}
LunaObject* & pObjFound = itFound->second;
pObjFound->Destory(); delete pObjFound;
pObjFound = NULLPTR_OBJECT;
} LunaObject * const ObjectManager::Find(int id)
{
const ObjectManager* pSelf = this; return const_cast<LunaObject * const>(pSelf->Find(id));
} const LunaObject * const ObjectManager::Find(int id) const
{
auto itFound = m_objects.find(id);
if (itFound == m_objects.end())
{
return NULLPTR_OBJECT;
}
return itFound->second;
}
};
Human.h(测试用) (将会被宏代替(一句宏生成一个类))
#pragma once
#include "LunaObject.h" namespace Lunacia
{
class Human : public LunaObject
{
public:
Human();
~Human(); public:
void QualitiesCorrelation() override;
};
};
Human.cpp(测试用)
#include "Human.h" namespace Lunacia
{
Human::Human()
{
} Human::~Human()
{
} void Human::QualitiesCorrelation()
{
//TODO: rebuild at config file.
PtrQuality ptrHeal = m_qualManager.AddQuality<QualHealth>();
PtrQuality ptrLifeIn = m_qualManager.AddQuality<QualLifeInstinct>();
PtrQuality ptrCour = m_qualManager.AddQuality<QualCourage>(); ptrHeal->SetLimit();
ptrHeal->SetValue(ptrHeal->GetLimit()); ptrLifeIn->SetLimit();
ptrHeal->SetValue(ptrLifeIn->GetLimit()); ptrCour->SetLimit();
ptrHeal->SetValue(ptrCour->GetLimit()); ptrLifeIn->AddPassive(ptrHeal);
ptrHeal->AddPassive(ptrCour); return;
} }
UniqueID.h(初版,用于测试)
#pragma once
#include "stdinc.h" namespace Lunacia
{
//Unique ID Local, not global.
class UniqueID final
{
public:
static int64_t Get(int8_t suffix_8bit = );
static void Load(void* pData); private:
static void ReInitPool(); private:
static const size_t _count = ; //TODO: Rebuild it. //The larger the number, the more uniform the distribution.
static int _curSize;
static int _curMax; //TODO: Rebuild it.
static std::array<int64_t, _count> _idsPool;
};
};
UniqueID.cpp
#include "UniqueID.h"
#include "Random.h" namespace Lunacia
{
int UniqueID::_curMax = ;
std::array<int64_t, UniqueID::_count> UniqueID::_idsPool;
int UniqueID::_curSize = UniqueID::_count; int64_t UniqueID::Get(int8_t suffix_8bit)
{
if (_curSize >= _idsPool.size() - )
{
ReInitPool();
} return (_idsPool[_curSize++] << ) | suffix_8bit;
} void UniqueID::Load(void* pData)
{ } void UniqueID::ReInitPool()
{
int curMin = _curMax;
_curMax += _count;
for (int i = ; i < _count; ++i)
{
_idsPool[i] = i + curMin;
} for (int n = ; n < _count - ; ++n)
{
uint64_t ran = RandomAvg::GetRandNum(n + , _count);
std::swap(_idsPool[n], _idsPool[ran]);
} _curSize = ;
}
};
Encounter.h(测试类)
#include "stdinc.h"
#include "QualDefine.h" #pragma once namespace Lunacia
{
class Encounter
{
public:
struct QualInfluence
{
QualityType type;
int32_t influence;
}; public:
Encounter();
~Encounter(); private:
QualityType GetRandomType() const;
int32_t GetRamdomInfluence() const; public:
void GetRandomInfluence(QualInfluence& __out res) const;
}; };
Encounter.cpp
#include <bitset> #include "Encounter.h"
#include "Random.h" namespace Lunacia
{ Encounter::Encounter()
{ } Encounter::~Encounter()
{ } QualityType Encounter::GetRandomType() const
{
int rand = static_cast<int>(RandomAvg::GetRandNum(, static_cast<uint32_t>(QualityType::__QualityType_MAX)));
return static_cast<QualityType>(rand);
} int32_t Encounter::GetRamdomInfluence() const
{ return g_rn.GetRandNum<int32_t>() * static_cast<int>(std::pow(-, RandomAvg::GetRandNum() % ));
} void Encounter::GetRandomInfluence(QualInfluence& res) const
{
res.type = GetRandomType();
res.influence = GetRamdomInfluence();
}
};
_main.cpp(测试用主函数)
#include "Tilee.h"
#include "Location.h"
#include "stdinc.h"
#include "Random.h"
#include "Rational.h" #include "ObjectManager.h"
#include "QualHealth.h"
#include "QualLifeInstinct.h" #include "LunaObject.h"
#include "Human.h"
#include "UniqueID.h"
#include "UClock.h" #include "Encounter.h" using namespace Lunacia; ObjectManager* pOm = new ObjectManager();
std::vector<LunaObject*> g_objs; RandomItem<LunaObject*> * g_ri;
Encounter g_ec; const std::function<uint64_t(const LunaObject* const &)>& GetWeightFunc = [](const LunaObject*const & obj) -> uint64_t
{
const Quality* const res = obj->m_qualManager.GetQuality(QualityType::HEALTH);
if (res == nullptr)
{
return 0l;
} return res->GetValue();
}; void loop()
{
Encounter::QualInfluence eqi;
g_ec.GetRandomInfluence(eqi); LunaObject* const pObj = g_ri->GetRandItem();
Quality* const res = pObj->m_qualManager.FindQuality(eqi.type); if (res == nullptr)
{
return;
}
res->AddValue(eqi.influence); std::cout<<"ID: " << pObj->Info().Get<int>("id") << " " << static_cast<int64_t>(eqi.type) << " : "<< eqi.influence << std::endl;
} void init(int count)
{
for (size_t i = ; i < count; i++)
{
LunaObject* h = pOm->Create<Human>();
h->QualitiesCorrelation(); int id = pOm->Add(h); g_objs.push_back(h);
} g_ri = new RandomItem<LunaObject*>(g_objs, GetWeightFunc);
} int main(void)
{
init();
const int64_t RateBase = ; int64_t Rate = RateBase / ;
UClock uck; int64_t pre = GetCurrentTime();
int64_t e = ;
int64_t cur = ;
uint64_t i = ; //TEST: Loop
while (true)
{
cur = GetCurrentTime();
e += cur - pre;
pre = cur; while (e >= Rate)
{
loop();
e -= Rate;
i++;
//std::cout << e << std::endl;
} if (i >= )
{
i = ;
delete g_ri;
g_ri = new RandomItem<LunaObject*>(g_objs, GetWeightFunc);
system("cls");
}
} system("pause");
return ;
}
C++ Object实体类的更多相关文章
- 关于java.lang.ClassCastException: [Ljava.lang.Object; cannot be cast to 实体类
由于业务逻辑的复杂,有些sql语句写法hql不支持,所以hibernate查询直接用了sql原生查询,由于数据结果根据四个表查询出来,所以无法使用方法.addEntity(XXXXXXX.class) ...
- 实体类和DataTable的转换
引子 最近在项目中在数据库查询的时间,总是要用到数据表到实体类对象列表的转化,自己封装了一个转换的方法,用起来还比较方便,记下来,以后可以重复使用,原理就主要是利用反射,当然有更好的ORM框架可以实现 ...
- [转]C#反射,根据反射将数据库查询数据和实体类绑定,并未实体类赋值
本文来自:http://www.cnblogs.com/mrchenzh/archive/2010/05/31/1747937.html /****************************** ...
- 【Java EE 学习 69 下】【数据采集系统第一天】【实体类分析和Base类书写】
之前SSH框架已经搭建完毕,现在进行实体类的分析和Base类的书写.Base类是抽象类,专门用于继承. 一.实体类关系分析 既然是数据采集系统,首先调查实体(Survey)是一定要有的,一个调查有多个 ...
- NHibernate生成实体类、xml映射文件
最近工作电脑装完win10后,之前使用的codeSmith安装不了,索性自己写一个. 界面比较简单,如下图: 第一行为Oracle数据库的连接字符串.连接成功后,填充表到第4行的下拉列表中. 第二行为 ...
- java 项目中几种O实体类的概念
经常会接触到vo,do,dto的概念,本文从领域建模中的实体划分和项目中的实际应用情况两个角度,对这几个概念进行简析. 得出的主要结论是:在项目应用中,vo对应于页面上需要显示的数据(表单),do对应 ...
- Hibernate的实体类为什么要实现Serializable序列化接口?
Hibernate的实体类中为什么要继承Serializable? hibernate有二级缓存,缓存会将对象写进硬盘,就必须序列化,以及兼容对象在网络中的传输 等等. java中常见的几个类(如 ...
- 【转】C#中将JSon数据转换成实体类,将实体类转换成Json
http://wo13145219.iteye.com/blog/2022667 http://json2csharp.chahuo.com/ using System; using System.C ...
- YbSoftwareFactory 代码生成插件【十九】:实体类配合数据库表字段进行属性扩展的小技巧
实体类通常需要和数据库表进行了ORM映射,当你需要添加新的属性时,往往同时也需要在数据库中添加相应的字段并配置好映射关系,同时可能还需对数据访问组件进行重新编译和部署才能有效.而当你开始设计一个通用数 ...
随机推荐
- 关于Linux时间设置的总结
系统环境:centos Linux的时间有两种,一种是系统时间,一种是硬件时间. 系统时间的查看:#date 系统时间的设置:#date -set 时间同步工具准备 Linux进行时间同步要使用一个工 ...
- OO第二单元总结之线程大冒险第一关
第二个单元的三次作业均为多线程电梯的设计,旨在让我们能够理解多线程在面向对象设计时的重要意义,并熟练掌握在保证线程安全和性能高效情况下的多线程协同的设计模式——在本次作业中主要体现在生产者-消费者模式 ...
- java跨域
在我们开发当中 经常会碰见跨域问题 今天我来说下 我在工作撞见的跨域: 一.首先我们要了解跨域存在的原因 1.浏览器限制 2.跨域(域名,端口不一样都是跨域) 3.XHR(XMLHttpReques ...
- 使用 navicat 导入导出数据库
1.使用 navicat 导出数据库 2.使用 navicat 导入数据库导入之前需要先建好数据库 3.可以直接使用navicat 到数据传输功能直接将一个数库copy到另一个数据库
- 关于MySQL什么时候使用索引问题以及什么情况下应不建或少建索引
一,什么情况下使用索引1. 表的主关键字 自动建立唯一索引 2. 表的字段唯一约束 ORACLE利用索引来保证数据的完整性 3. 直接条件查询的字段 在SQL中用于条件约束的字段 如zl_yhjbqk ...
- 关于IEDA中的字母与数字的坑
今天写一个demo,环境是在IDEA下写的,遇到一个关于字母与数字完全一样的坑 在jsp页面中有一个input是这样的 <input type="file" name=&qu ...
- HML
1.元素分类: 2.浮动: 在非IE浏览器(如Firefox)下,当容器的高度为auto,且容器的内容中有浮动(float为left或right)的元素,在这种情况下,容器的高度不能自动伸长以适应内容 ...
- Python3.x - 字符串
Python3 字符串 字符串是 Python 中最常用的数据类型.我们可以使用引号( ' 或 " )来创建字符串. var1 = 'hello world' var2 = "he ...
- mysql 索引查询 、创建 create index 与 add index 的区别
1.索引查询 ------TABLE_SCHEMA 库名:TABLE 表名 ------AND UPPER(INDEX_NAME) != 'PRIMARY' 只查询索引,不需要主键 SELECT ...
- C#创建、读写、增加、删除XML操作
using System;using System.Collections.Generic;using System.Linq;using System.Text;using System.Threa ...