cocos2d-x sqlite 封装类

最新推荐文章于 2019-10-30 20:27:37 发布
最新推荐文章于 2019-10-30 20:27:37 发布
阅读量486 收藏 1
点赞数
分类专栏： cocos2d-x
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jintuo/article/details/48006487
版权

网上的封装类说心里话，用的很不舒服。

不知道其他的C++程序员用的数据库封装都是什么样子，至少对我这种PHP过来的程序员来说，这种还需要完全自己写sql的数据库封装类用起来很痛苦。


所以，为了以后不痛苦，只能现在痛苦一下了。把网上的类重新改了下

DBUtil.h

//
//  DBUtil.h
//
//  Created by Ron on 15/8/25.
//
//

#ifndef __DBUtil__
#define __DBUtil__

#include "sqlite3.h"
#include "cocos2d.h"

USING_NS_CC;

class DBUtil {
    
private:
    
    //数据库
    sqlite3* m_pDataBase;
    
private:
    
#pragma mark <构造 && 析构>
    
    DBUtil();
    
    virtual ~DBUtil();
    
public :
    
#pragma mark <创建 && 销毁单例>
    
    static DBUtil* getInstance();
    
    static void destoryInstance();
    
#pragma mark <自定义数据库操作>
    void resetParam();//重置操作数据
    
    /**
     *  创建表
     *
     *  @param where where条件字符串
     */
    void createTable(std::vector<std::string> param, std::string primaryName);
    
    /**
     *  table表名
     *
     *  @param where where条件字符串
     */
    DBUtil* table(std::string tableName);
    
    /**
     *  where条件
     *
     *  @param where where条件字符串
     */
    DBUtil* where(std::string where);
    
    /**
     *  插入数据
     *
     *  @param param 要插入的数据
     */
    int insert(std::map<std::string, std::string> param);
    
    /**
     *  查询，返回多个条件
     */
    std::vector<std::map<std::string, std::string>> select();
    
    /**
     *  查询，返回一个条件
     */
    std::map<std::string, std::string> find();
    
    /**
     *  查询，返回个数
     */
    int count();
    
    /**
     *  更新数据
     *
     *  @param param 要插入的数据
     */
    int update(std::map<std::string, std::string> param);
    
    /**
     *  删除
     */
    int del();
    
private:
    std::string ron_tableName;
    std::string ron_where;
    
    
public:
#pragma mark <数据库操作>
    
    /**
     *  打开数据库(创建)
     *
     *  @param aDataBaseName 数据库名
     */
    void openDBWithName();
    
    /**
     *  关闭数据库
     */
    void closeDB();
    
    /**
     *  创建数据表
     *
     *  @param aSql       建表sql语句
     *  @param aTableName 表名
     */
    void createTable(std::string aSql, std::string aTableName);
    
    /**
     *  通过表名查询该表是否存在
     *
     *  @param aTabelName 表秒
     *
     *  @return true: 存在 false: 不存在
     */
    bool isExistTableByName(std::string aTabelName);
    
    /**
     *  删除数据表
     *
     *  @param aSql       删表sql语句
     *  @param aTableName 表名
     */
    void deleteTable(std::string aSql, std::string aTableName);
    
    /**
     *  开始事务
     *
     *  @return 操作结果(sqlite3提供的宏)
     */
    int beginTransaction();
    
    /**
     *  提交事务(失败回滚)
     *
     *  @param aResult       操作结果
     *
     *  @return 操作结果(sqlite3提供的宏)
     */
    int comitTransaction(int aResult);
    
};

#endif /* defined(__DBUtil__) */

DBUtil.cpp 

//
//  DBUtil.cpp
//
//  Created by ron on 15/8/25.
//
//

#include "DBUtil.h"

static DBUtil* s_pInstance = NULL;

const std::string cDBName = "gamedb";

#pragma mark <构造 && 析构>

DBUtil::DBUtil():m_pDataBase(NULL),ron_where(""),ron_tableName("")
{
    
}

DBUtil::~DBUtil() {
    
}

#pragma mark <创建 && 销毁单例>

DBUtil* DBUtil::getInstance() {
    if (!s_pInstance) {
        s_pInstance = new DBUtil();
    }
    return s_pInstance;
}

void DBUtil::destoryInstance() {
    delete s_pInstance;
    s_pInstance = NULL;
}

#pragma mark <数据库操作>

/**
 *  打开数据库(创建)
 *
 *  @param aDataBaseName 数据库名
 */
void DBUtil::openDBWithName() {
    std::string writeablePath = FileUtils::getInstance()->getWritablePath();
    CCLOG("path=%s", writeablePath.c_str());
    std::string dbPath = writeablePath + cDBName;
    
    int result = sqlite3_open(dbPath.c_str(), &m_pDataBase);
    char* errMsg = NULL;
    if (result != SQLITE_OK) {
        log("打开数据库失败，错误码:%d，错误原因:%s\n", result, errMsg);
    }
    
    if (errMsg) {
        sqlite3_free(errMsg);
        errMsg = NULL;
    }
}

/**
 *  关闭数据库
 */
void DBUtil::closeDB() {
    if (m_pDataBase) {
        sqlite3_close(m_pDataBase);
        m_pDataBase = NULL;
    }
}

/**
 *  创建数据表
 *
 *  @param aSql       建表sql语句
 *  @param aTableName 表名
 *
 *  @usage string sql = "create table user(id integer, username text, password text)";
 */
void DBUtil::createTable(std::string aSql, std::string aTableName) {
    
    openDBWithName();
    
    if (!isExistTableByName(aTableName)) {
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, aSql.c_str(), NULL, NULL, &errMsg);
        if (result != SQLITE_OK) {
            log("创建表失败，错误码:%d，错误原因:%s\n", result, errMsg);
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
    }
    
    closeDB();
}

/**
 *  是否存在某张数据表的查询回调
 *
 *  @return 0
 */
int isExistTableCallback(void* para, int n_column, char ** column_value, char ** column_name) {
    bool *isExisted_= (bool*)para;
    *isExisted_= (**column_value) != '0';
    return 0;
}

/**
 *  通过表名查询该表是否存在
 *
 *  @param aTabelName 表秒
 *
 *  @return true: 存在 false: 不存在
 */
bool DBUtil::isExistTableByName(std::string aTabelName) {
    
    if (m_pDataBase) {
        //判断表是否存在
        bool isExist;
        char* errMsg = NULL;
        std::string sql = "select count(type) from sqlite_master where type = 'table' and name = '" + aTabelName + "'";
        int result = sqlite3_exec(m_pDataBase, sql.c_str(), isExistTableCallback, &isExist, &errMsg);
        
        if (result != SQLITE_OK) {
            log("查询表是否存在失败，错误码:%d，错误原因:%s\n", result, errMsg);
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
        
        return isExist;
    }
    
    return false;
}

/**
 *  删除数据表
 *
 *  @param aSql       删表sql语句
 *  @param aTableName 表名
 *
 *  @usage string sql = "drop table name";
 */
void DBUtil::deleteTable(std::string aSql, std::string aTableName) {
    
    openDBWithName();
    
    beginTransaction();
    
    int result = 0;
    if (isExistTableByName(aTableName)) {
        char* errMsg = NULL;
        result = sqlite3_exec(m_pDataBase, aSql.c_str(), NULL, NULL, &errMsg);
        if (result != SQLITE_OK) {
            log("创建表失败，错误码:%d，错误原因:%s\n", result, errMsg);
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
    }
    
    comitTransaction(result);
    
    closeDB();
    
}

/**
 *  开始事务
 *
 *  @return 操作结果(sqlite3提供的宏)
 */
int DBUtil::beginTransaction() {
    char* errMsg = NULL;
    int result = sqlite3_exec(m_pDataBase, "begin transaction", 0, 0, &errMsg);
    if (result != SQLITE_OK ){
        log("开始事务记录失败，错误码:%d，错误原因:%s\n", result, errMsg);
    }
    return result;
}

/**
 *  提交事务(失败回滚)
 *
 *  @param aResult       操作结果
 *
 *  @return 操作结果(sqlite3提供的宏)
 */
int DBUtil::comitTransaction(int aResult) {
    if (aResult == SQLITE_OK) {
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, "commit transaction", 0, 0, &errMsg);
        if (result != SQLITE_OK) {
            log("提交事务记录失败，错误码:%d，错误原因:%s\n" , result, errMsg);
        }
        return result;
    } else {
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, "rollback transaction", 0, 0, &errMsg);
        if (result != SQLITE_OK ) {
            log("回滚事务记录失败，错误码:%d，错误原因:%s\n", result, errMsg);
        }
        return result;
    }
}

#pragma mark 自定义数据库操作
DBUtil* DBUtil::table(std::string tableName)
{
    ron_tableName = tableName;
    
    return DBUtil::getInstance();
}

DBUtil* DBUtil::where(std::string where)
{
    std::string str = " WHERE ";
    ron_where =  str.append(where);
    
    return DBUtil::getInstance();
}

/**
 *  重置操作数据
 */
void DBUtil::resetParam()
{
    ron_tableName = "";
    ron_where = "";
}

/**
 *  查询回调
 *
 *  @return 0
 */
int selectCallback(void* para, int n_column, char** column_value, char** column_name ) {
    std::map<std::string, std::string> mapResults ;
    for (int i = 0; i < n_column; i++) {
        mapResults.insert(std::make_pair<std::string, std::string>((std::string)column_name[i], (std::string)column_value[i]));
    }
    std::vector<std::map<std::string, std::string> >* vect = (std::vector<std::map<std::string, std::string> >*)para;
    vect->push_back(mapResults);
    return 0;
}

std::vector<std::map<std::string, std::string>> DBUtil::select()
{
    //vector是查询的结果集，每一个结果都存在map中
    //map的第一string是key(字段名)，第二个string是value(查询出的对应数据)
    std::vector<std::map<std::string, std::string> > vec;
    
    try {
        if (ron_tableName.empty()) {
            throw 0;//表名为空的话，则抛出异常
        }
        openDBWithName();
        
        std::string sql = "SELECT * FROM ";
        
        sql.append(ron_tableName);
        sql.append(ron_where);
        
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, sql.c_str(), selectCallback, &vec, &errMsg);
        if (result != SQLITE_OK) {
            log("查询失败，错误码:%d，错误原因:%s\n", result, errMsg);
            throw 0;
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
            throw 0;
        }
        
        resetParam();
        closeDB();
    } catch (...) {
        std::vector<std::map<std::string, std::string>> empty;
        resetParam();
        closeDB();
        
        return empty;
    }

    return vec;
}

/**
 *  查询回调
 *
 *  @return 0
 */
int findCallback(void* para, int n_column, char** column_value, char** column_name ) {
    std::map<std::string, std::string> mapResults ;
    
    mapResults.insert(std::make_pair<std::string, std::string>((std::string)column_name[0], (std::string)column_value[0]));
    for (int i = 0; i < n_column; i++) {
        mapResults.insert(std::make_pair<std::string, std::string>((std::string)column_name[i], (std::string)column_value[i]));
    }
    std::map<std::string, std::string>* map = (std::map<std::string, std::string>*)para;
    *map = mapResults;

    return 0;
}

std::map<std::string, std::string> DBUtil::find()
{
    //map的第一string是key(字段名)，第二个string是value(查询出的对应数据)
    std::map<std::string, std::string> map;
    
    try {
        if (ron_tableName.empty()) {
            throw 0;//表名为空的话，则抛出异常
        }
        openDBWithName();
        
        std::string sql = "SELECT * FROM ";
        
        sql.append(ron_tableName);
        sql.append(ron_where);
        sql.append(" LIMIT 1");
        
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, sql.c_str(), findCallback, &map, &errMsg);
        if (result != SQLITE_OK) {
            log("查询失败，错误码:%d，错误原因:%s\n", result, errMsg);
            throw 0;
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
            throw 0;
        }
        
        resetParam();
        closeDB();
    } catch (...) {
        resetParam();
        closeDB();
        std::map<std::string, std::string> empty;
        
        return empty;
    }
    
    return map;
}

/**
 *  查询数据条数回调
 *
 *  @return 0
 */
int countCallback(void* para, int n_column, char** column_value, char** column_name) {
    int* count = (int*)para;
    *count = (int)atof(column_value[0]);
    return 0;
}

/**
 *  查询记录的条数
 *
 *  @param sql 查询记录sql语句
 *
 *  @return 记录条数
 */
int DBUtil::count() {
    int count = 0;
    try {
        if (ron_tableName.empty()) {
            throw 0;//表名为空的话，则抛出异常
        }
        openDBWithName();
        
        std::string sql = "SELECT * FROM ";
        
        sql.append(ron_tableName);
        sql.append(ron_where);
        
        char* errMsg = NULL;
        int result = sqlite3_exec(m_pDataBase, sql.c_str(), countCallback, &count, &errMsg);
        if (result != SQLITE_OK) {
            log("查询失败，错误码:%d，错误原因:%s\n", result, errMsg);
            throw 0;
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
            throw 0;
        }
        
        resetParam();
        closeDB();
    } catch (...) {
        resetParam();
        closeDB();
        
        return 0;
    }
    
    return count;
}

void DBUtil::createTable(std::vector<std::string> param, std::string primaryName)
{
    try {
        if (ron_tableName.empty()) {
            throw 0;//表名为空的话，则抛出异常
        }
        openDBWithName();
        
        std::string sql = "CREATE TABLE ";
        
        sql.append(ron_tableName);
        sql.append("(");
        
        for (auto value : param) {
            sql.append(value);
            if (value == primaryName) {
                sql.append(" INTEGER PRIMARY KEY AUTOINCREMENT");
            }
            sql.append(",");
        }
        
        sql.erase(sql.end()-1);
        sql.append(")");
        
        if (!isExistTableByName(ron_tableName)) {
            char* errMsg = NULL;
            int result = sqlite3_exec(m_pDataBase, sql.c_str(), NULL, NULL, &errMsg);
            if (result != SQLITE_OK) {
                log("创建表失败，错误码:%d，错误原因:%s\n", result, errMsg);
            }
            
            if (errMsg) {
                sqlite3_free(errMsg);
                errMsg = NULL;
            }
        }
    } catch (...) {
        
    }
    
    resetParam();
    closeDB();
}

int DBUtil::insert(std::map<std::string, std::string> param)
{
    int result = 0;
    try {
        if (ron_tableName.empty()) {
            throw 0;//表名为空的话，则抛出异常
        }
        
        openDBWithName();
        
        beginTransaction();
        
        std::string sql = "INSERT INTO ";
        sql.append(ron_tableName);
        sql.append(" (");
        
        for (std::map<std::string, std::string>::iterator i = param.begin(); i != param.end(); i++) {
            sql.append(i->first);
            sql.append(",");
        }
        sql.erase(sql.end()-1);
        sql.append(") VALUES (");
        
        for (std::map<std::string, std::string>::iterator i = param.begin(); i != param.end(); i++) {
            sql.append("\"");
            sql.append(i->second);
            sql.append("\",");
        }
        sql.erase(sql.end()-1);
        sql.append(");");
        
        char* errMsg = NULL;
        result = sqlite3_exec(m_pDataBase, sql.c_str(), NULL, NULL, &errMsg);
        if (result != SQLITE_OK) {
            log("插入记录失败，错误码:%d，错误原因:%s\n", result, errMsg );
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
        
        comitTransaction(result);
        
    } catch (...) {
        result = 1;
    }
    
    resetParam();
    closeDB();
    
    return result;
}

int DBUtil::update(std::map<std::string, std::string> param)
{
    int result = 0;
    try {
        if (ron_tableName.empty() || ron_where.empty()) {
            throw 0;//表名为空或者where条件为空的话，则抛出异常
        }
        
        openDBWithName();
        
        beginTransaction();
        
        std::string sql = "UPDATE ";
        sql.append(ron_tableName);
        sql.append(" SET ");
        
        for (std::map<std::string, std::string>::iterator i = param.begin(); i != param.end(); i++) {
            sql.append(i->first);
            sql.append("=\"");
            sql.append(i->second);
            sql.append("\",");
        }
        sql.erase(sql.end()-1);
        
        sql.append(ron_where);
        
        char* errMsg = NULL;
        result = sqlite3_exec(m_pDataBase, sql.c_str(), NULL, NULL, &errMsg);
        if (result != SQLITE_OK) {
            log("更新记录失败，错误码:%d，错误原因:%s\n", result, errMsg );
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
        
        comitTransaction(result);
    } catch (...) {
        result = 1;
    }
    
    resetParam();
    closeDB();
    
    return result;
}

int DBUtil::del()
{
    int result = 0;
    try {
        if (ron_tableName.empty() || ron_where.empty()) {
            throw 0;//表名为空或者where条件为空的话，则抛出异常
        }
        
        openDBWithName();
        
        beginTransaction();
        
        std::string sql = "DELETE FROM ";
        sql.append(ron_tableName);
        sql.append(ron_where);
        
        char* errMsg = NULL;
        result = sqlite3_exec(m_pDataBase, sql.c_str(), NULL, NULL, &errMsg);
        if (result != SQLITE_OK) {
            log("删除记录失败，错误码:%d，错误原因:%s\n", result, errMsg );
        }
        
        if (errMsg) {
            sqlite3_free(errMsg);
            errMsg = NULL;
        }
        
        comitTransaction(result);
    } catch (...) {
        result = 1;
    }
    
    resetParam();
    closeDB();
    
    return result;
}

用法也很简单 

std::vector<std::string> param;
        param.push_back("id");
        param.push_back("name");
        param.push_back("age");
        
        DBUtil::getInstance()->table("rontab2")->createTable(param, "id");//建表
        
        std::map<std::string, std::string> m;
        m["name"] = "wahaha";
        m["age"] = "年龄";
        
        DBUtil::getInstance()->table("rontab3")->insert(m);//添加
        
        auto data = DBUtil::getInstance()->table("rontab3")->select();//查找
        
        DBUtil::getInstance()->where("id = 8")->table("rontab3")->update(m);//更新
        
        DBUtil::getInstance()->where("id=3")->table("rontab3")->del();//删除

这种增删改查是不是简单到没朋友？


不过实话实说。缺陷还是不少。

首先，建表只能建无类型的，虽然sqlite会自动转换，但是由于我的insert和update的缺陷，导致，除了主键，其他都是字符串类型。


还有，代码里的string字符串连接确实有点坑爹了。真心对C++不太熟悉，图省事，就先这样了。


确实有很多可以优化的地方，但是，封装这样一个类真心对我来说太枯燥。我宁肯写10000行代码去开发游戏的逻辑，也不想写100行这种代码。所以，先这样吧，以后哪天心情好了，再重新优化一下吧。或者哪位兄弟无聊也可以为人类做下贡献：）

金拓
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cocos2d-x封装的sqlite3开源库
05-24
cocos2d-x封装的sqlite3开源库，简便很多
cocos2d-x-3rd-party-libs-src:cocos2d-x的依存关系
05-28
cocos2d-x第三方库 该存储库包含与cocos2d-x捆绑在一起的第三方库（二进制）的源代码。 对于cocos2d-x开发人员和/或想要： 生成特定库的更新版本（例如：将libpng 1.6.2升级到1.6.14） 将cocos2d-x移植到其他平台...
【Cocos2d-x游戏引擎开发笔记(20)】SQLite专题
modabobo
03-04 131
原创文章，转载请注明出处：http://blog.csdn.net/zhy_cheng/article/details/8634967。 大家好，很长一段时间没有跟新我的博客，看到大家在我的博客里的留言，我很是欣慰。这次我给大家带来了cocos2d-x使用SQLite数据库的博文。 在cocos2d-x中，简单数据存储，可以使用CCUserDefault，大家可以看看我前一篇博文。至于...
cocos2d-x学习笔记17：记录存储2：SQLite基本使用
weixin_34367257的博客
02-04 163
 cocos2d-x学习笔记17：记录存储2：SQLite基本使用 一、安装与配置 SQLite是使用非常广泛的嵌入式数据库，它有着0配置，占用资源少等特点。从大型游戏《魔兽世界》到android上的很多游戏和软件（google提供了一个java语言的绑定。） 在cocos2d-x中，我们使用它的C语言绑定。 为了方便和简化篇幅，我们直接使用它的源代码。下载地址： htt...
Cocos2d-x 分享一个封装的Sqlite3的DBUtil类
CC专栏
12-27 2330
分享一个Cocos2d-x访问Sqlite3数据库的单例的DBUitl类，对增删改查以及事务操作等常用的API进行了一下简单的封装，还有很多不太完善的地方，希望大家帮我改进。 分别对Cocos的2.x版本和3.x版本进行了封装。 2.x版
cocos2d-x中使用sqlite
weixin_34066347的博客
06-20 93
在单机游戏中有几十个场景道具，每一个都有各自的状态（获得、未获得、获得个数）等等，如果在游戏中平凡涉及到这些道具的实时存储，那么使用文本就会稍慢、可以使用sqlite数据库来完成。 下载地址：http://www.sqlite.org/download.html 下载后，在项目中导入sqlite3.c和sqlite3.h两个文件即可。 附上使用代码：（如果表不存在，创建两个表、存...
Cocos2d-Lua-社区：基于Cocos2d-x 4.0，打造易用稳定的Cocos2d-x lua引擎
02-03
Cocos2d-Lua社区Cocos2d-Lua-Community是Cocos2d-x 4.0的改进，并且易于使用Lua游戏引擎。 它是与Quick-Cocos2dx-Community v3.7.x兼容的Lua“框架”。得到帮助 QQ群：社区版千人群（1群）号：361920466社区版2群：...
Cocos2d-x实战：JS卷——Cocos2d-JS开发
07-23
资源名称：Cocos2d-x实战：JS卷——Cocos2d-JS开发内容简介：本书是介绍Cocos2d-x游戏编程和开发技术书籍，介绍了使用Cocos2d-JS中核心类、瓦片地图、物理引擎、音乐音效、数据持久化、网络通信、性能优化、多平台...
cocos2d-x事件类
05-13
在使用cocos2d-x开发游戏的过程中，为了实现逻辑和显示相分离。 在下通宵了一个晚上，写出了该事件类。 谨记，该事件只能用于cocos2d-x中。 事件发送者需要继承EventDispatcher类 事件接收者需要继承EventHandle类...
经典版本 方便下载 源码 旧版本 3.8 官网找不到了 cocos2d-x-3.8.zip
03-14
经典版本 方便下载 源码 旧版本 3.8 官网找不到了 cocos2d-x-3.8.zip
Cocos2d-x笔记（三）Sqlite数据库封装
Thinking in code
10-19 1670
为方便使用，简单的封装了一下Sqlite数据库的操作。 头文件如下： class SqliteUtil { private: sqlite3* pDB; char* errMsg; SqliteUtil(void); ~SqliteUtil(void); public: /**获取实例 */ static SqliteUtil* getInstance(); /*
cocos2d-x 3.2 Sqlite封装类（一）
08-14 1251
学习操作Sqlite时，简单封装了一个SQLiteHelper操作类。
Cocos2d 使用Sqlite
在代码身上，用心去飞翔
09-27 1125
首先下载sqlite的源码，一共4个文件，添加到项目中 包含头文件： #include "sqlite3.h" 创建或打开数据库： [cpp] view plaincopy //打开一个数据库文件，如果不存在，则创建一个数据库文件    int result=sqlite3_open("game.db"
cocos2d - sqlite 简单使用
pyf_914406232的博客
10-30 282
首先我这边有一个对sqlite使用的简单封装类DBUtil，这个是前辈留下来的东西，我就直接拿来使用了. 先把类添加进我们的工程中，我们这个是c++的工程： 这是我的项目目录，直接放进去之后编译会报错，有很多个方法找不到，这个时候需要把sqlite的lib库导入到工程中： 然后在链接器-输入-附加依赖项 增加sqlite3.lib 这样编译就可以通过了。如果编译通过说明环境...
在cocos2d-x中使用sqlite
daregone_3824的专栏
12-23 242
sqlite数据库在移动平台上应用非常广泛，功能也非常强大。在IOS平台上的使用非常方便。 首先，导入sqlite3。点击“Targets”-“Build Phases”-“Link Binary With Libraries”,点击“+”号，添加libsqlite3.dylib. 然后，在代码中添加头文件sqlite.h，就可以用了。如： 从数据库中读取数据： sqlite3 *pDB =
Cocos2d-X 学习笔记 18 Cocos2dx 下对sqlite3 的简单封装
huahua12300的专栏
10-23 801
DBUtil.h: [cpp] view plaincopy class DBUtil{             public:              /************************************************************              封装 sqlite3操作 
cocos2d-x SQLite基本使用
z104207的专栏
04-28 5107
一、安装与配置 SQLite是使用非常广泛的嵌入式数据库，它有着0配置，占用资源少等特点。从大型游戏《魔兽世界》到android上的很多游戏和软件（google提供了一个java语言的绑定。） 在cocos2d-x中，我们使用它的C语言绑定。 为了方便和简化篇幅，我们直接使用它的源代码。下载地址： http://www.sqlite.org/sqlite-ama
Cocos2d-x笔记（二）Sqlite数据库基本操作
Thinking in code
10-08 1892
简单的数据可以使用文件方式存储，CCUserDefault、CCFileUtil等类都可以完成文件的存储。如数据量比较大、或涉及增删改比较多，就需要考虑使用数据库。以前一直做 android开发，一想到数据库肯定是Sqlite。             Sqlite数据库本身就是C语言编写的，官方也已经提供了Sqlite的API，这样工作就轻松多了。 1.先到Sqlite官网上下载源码ht
cocos2dx sqlite3封装使用
Cui860的专栏
07-07 786
[cpp] view plaincopyprint? /*   * DB.h   *   *  Created on: 2013-6-8   *      Author: zhuang   */            #ifndef _DB_H_   #define _DB_H_   #include "cocos2d.h"   // DB  
如何学习cocos2d-x
最新发布
07-17
cocos2d-x 4. 学习之路 cocos2d-x是一款开源的跨平台游戏引擎，支持多种平台，包括iOS、Android、Windows、Mac OS X等。cocos2d-x 4.是最新版本，相比之前版本，它有很多新特性和改进，如增强的渲染性能、更好的3D...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值