Error

C++博客 首页 新随笔 联系 聚合 管理
  217 Posts :: 61 Stories :: 32 Comments :: 0 Trackbacks

#

查看和设置ndk使用的gcc版本
设置toolchain的方法是在Application.mk中设置:
NDK_TOOLCHAIN_VERSION = 4.7
为了确认是否设置成功,在ndk-build调用时增加参数V=1。即 ndk-build V=1 ..其他参数..
结果会显示:
/Developer/sdks/Android-ndk-r8e/toolchains/arm-Linux-androideabi-4.7/prebuilt/darwin-x86_64/bin/arm-Linux-androideabi-g++ -MMD -MP -MF ....
posted @ 2017-03-31 19:32 Enic 阅读(23) | 评论 (0)编辑 收藏

// lambda_test.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
#include <iostream>
#include <functional>
// 利用rtii观察堆栈生命周期
class StackLifeTimeWatching
{
public:
StackLifeTimeWatching()
{
std::cout << __FUNCTION__ << std::endl;
}
~StackLifeTimeWatching()
{
std::cout << __FUNCTION__ << std::endl;
}
};
// 经验: 保存lambda表达式的变量被销毁后,该表达式对应的闭包会销毁。应该保证闭包在lambda表达式变量的生命周期之内执行,否则程序执行结果不可预知!
// 1.理解lambda首先要理解函数对象,和闭包
// 2.理解必包的基础上,理解lambda如何实现闭包
// 3.理解闭包以后,需要分析设置不同的capture的情况下分别是如何实现闭包
//   1)闭包意味着一个函数地址 + 一组封装好的参数。
//   2)闭包可以被拷贝,但是每个闭包中的参数可以是不一样的
// 4.理解函数对象和lambda的关系: lambda可以理解成函数,但是当lambda赋值给一个函数对象的时候,编译器应该是把lambda构造成了一个闭包的function
//   1)根据汇编码分析,lambda对象类似于函数指针(但是类型系统和函数指针是完全不同的概念,可以用decltype(lambda)来鉴定),本质和函数对象是不一样的。
//   2)定义一个lambda表达式相当于定义一个函数(观察会变码,lambda表达式是没有构造和析构的)
//   3)把函数指针赋值给一个std::function,和吧lambda赋值给一个std::function的效果是完全不一样的。一个这是指针赋值操作,另一个则是完整的闭包。
//   4)经过代码实际测试,lambda是鉴于函数指针和函数对象之间的一个玩意,它也是一个特殊的类型,这个具体只能看C++标准文档了。
//   5)boost asio异步接口中的functor可能是利用了meta编程技巧,或者他本身每一次发起异步操作都会形成一个独立的闭包,解决了函数对象和socket对象生命周期绑定的关系
//      应为如果是functor实现,宿主对象析构,一定会造成作为成员变量的functor销毁,同时引起lambda闭包混乱(不仅闭包参数乱掉,闭包函数本身也呈现混乱)。
//      由此分析,闭包中的任何一行代码都必须在闭包本身的声明周期内执行。似乎可以理解成,lambda闭包是把lambda函数本身也当作一个特殊的参数来完成闭包封装的。
//      通过会变码观察,在使用不同的lambda变量调用lambda表达式的时候,会在ecx寄存器压入不同的值,然后会读取一块关联的内存。
//   6)vc2015下的lambda永远都是4字节,这应该是编译器实现细节了,按说应该是随着闭包内容的大小变化而变化。我猜测,这四个字节应该指向一个块内存,里边的数据是用来还原“lambda”函数执行栈的闭包
// 5.通俗的理解上述分析: lambda对象(变量)是一块内存,内存里边是lambda表达式本身的副本。当执行lambda表达式对象的时候,实际是执行对象对应的内存中的代码,如果对象被析构了,对应的代码也就是未知代码。
void Test1();
void Test2();
int main()
{
Test2();
    return 0;
}
void Test2()
{
int n = 0;
auto lambda = [&]()->void
{
StackLifeTimeWatching stackWatching;
n = 1;
int j = 0;
int j1 = 0;
int j2 = 0;
int j3 = 0;
int j4 = 0;
int j5 = 0;
};
decltype(&lambda) pLambda0 = &lambda;
decltype(&lambda) pLambda = NULL;
int nSize = sizeof(lambda);
{
decltype(lambda) lambda_copy = lambda;
lambda_copy();
}
(*pLambda0)();  // 正常掉用
(*pLambda)();  // 调用后整个闭包混乱
}
void Test1()
{
StackLifeTimeWatching p();
int n = 0;
std::function<void()> func;
std::function<void()>* pFunc = new std::function<void()>;
{
//std::function<void()> func = [&]()->void
//{
// StackLifeTimeWatching stackWatching;
// n = 1;
//};
//func();
auto lambda = [&]()->void
{
StackLifeTimeWatching stackWatching;
n = 1;
};
lambda();
func = lambda;
auto lambda2 = [&]()->void
{
delete pFunc;
pFunc = NULL;
StackLifeTimeWatching stackWatching;
n = 1;
};
//decltype(lambda) lambda_copy = lambda2; 编译错误,应为编译器会把每一个lambda表达式当作一个独立的类型,这是lambda不同于函数指针的地方,函数指针是根据参数来决定类型的
decltype(lambda) lambda_copy = lambda;
*pFunc = lambda2;
}
func();
(*pFunc)();
}
posted @ 2017-03-22 22:41 Enic 阅读(136) | 评论 (0)编辑 收藏

实现在CCGeometry.js
Point:
type: cc.Point(x,y)
help functon: 
cc.p(x,y)
cc.pointEqualToPoint(p1, p2)
cc.Size()
cc.size();
cc.sizeEqualToSize
cc.Rect()
cc.rect()
cc.rectEqualToRect()
cc._rectEqualToZero()
cc.rectContainsRect()
cc.rectGetMaxX
cc.rectGetMidX
cc.rectGetMinX
cc.rectGetMaxY
cc.rectGetMidY
cc.rectGetMinY
cc.rectContainsPoint
cc.rectIntersertsRect
cc.rectOverlapsRect
cc.rectUnion
cc.rectInterserction
// 可视区域
cc.visibleRect()


经过实际调试:
Point: 有x y属性可以直接使用
Size: width height
Rect: x y width height
posted @ 2017-03-19 10:54 Enic 阅读(20) | 评论 (0)编辑 收藏

1.创建的时候给明确地址和端口,创建完成后直接可以accept
2.open bind listen accept完整套路
posted @ 2017-03-16 21:56 Enic 阅读(10) | 评论 (0)编辑 收藏

1.直接close:客户端接收数据不完整,本地系统关闭socket,客户端收不到完整数据
2.shutdown_both:客户端接收数据不完整,end of file
3.shutdown_receive: 客户端接收数据完整
3.shutdown_send: 客户端接收数据不完整,远程主机关闭链接
关闭socket,但是确保对端一定收到数据的手段是:
1.shutdown_receive,同时在应用层确认全部数据已经投递到tcp堆栈,然后调用close
2.设计应用层关闭协议,由接收方主动关闭
posted @ 2017-03-16 21:54 Enic 阅读(21) | 评论 (0)编辑 收藏

apt-get install mysql-server
apt-get install apache2
apt-get install php5
apt-get install php5-mysql
apt-get install php5-gd
apt-search php5
apt-get install libapache2-mod-php5.6
apt-get install libapache2-mod-auth-mysql
apt-get install openjdk
sudo apt-get purge openjdk/openjdk
apt-get install python-software-properties
apt-get install software-properties-common
apt-get install -y language-pack-en-base
LC_ALL=en_US.UTF-8 add-apt-repository ppa:ondrej/php
add-apt-repository ppa:ondrej/php
apt-get update
apt-cache search php5
apt-get install php5.5-common
apt-get install libapache2-mod-php5.5
apt-get install php5.6
apt-get install php5.6-mysql
apt-get install php5.6-gd
apt-get install php7.1-mcrypt
apt-get install php-mbstring
apt-get install php7.1-mbstring
lsof -i:80   权限查询
/etc/init.d/apache2 restart
netstat -tupln
/etc/apache2/ports.conf
vi /etc/apache2/sites-enabled/000-default.conf  修改默认站点的root路径
sudo apt-get install phpmyadmin
ln -s /usr/share/phpmyadmin
sudo apt-get install wordpress
ln -s /usr/share/wordpress
cp wp-config-sample.php wp-config.php
vi wp-config.php
mysql: create database WordPress
ls /usr/share
ls /var/www/
WordPress
posted @ 2017-03-10 14:13 Enic 阅读(17) | 评论 (0)编辑 收藏

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

#include "stdafx.h"

#include <iostream>
#include <cmath>
#include <random>
#include <cstdint>
#include <ctime>
#include <algorithm>
#include <numeric>
#include <cassert>
#include <climits>
#include <thread>

#define XASSERT(exp) assert(exp)
#define XASSERT_MSG(exp, msg) assert(exp)
#define X_DEFAULT_FLOAT_PRECISION (0.00000001)

// @in: 总次数、目标比例(千分比)、算法类型(1.c标准库rand; 2.cpp11 mt19937)
// @out: 实际命中次数、实际命中概率
bool RandomHitTest(int32_t nTotalCount, float fHitRate, int32_t nAlgorithmType, int32_t& nRealHitCount, float& fRealHitRate);
void RandomHitTest_std_mt19937(int32_t nTotalCount, float fHitRate, int32_t& nRealHitCount, float& fRealHitRate);
void RandomHitTest_std_rand(int32_t nTotalCount, float fHitRate, int32_t& nRealHitCount, float& fRealHitRate);
// 简化std::rand获取[nMin, nMax]区间的一个数字
uint32_t StdRandEx(uint32_t nMin, uint32_t nMax);


int _tmain(int argc, _TCHAR* argv[])
{
    //std::thread srandThread([](){ std::this_thread::sleep_for(std::chrono::seconds(1));});
    
//srandThread.detach();

    std::vector<std::tuple<floatfloat>> vecResult;

    for (int n = 0; n < 1000; n++)
    {
        uint32_t nTotalCount = 100000;  // 基数100000次

        for (float fHitRate = 0.001f; 1.f - fHitRate >= 0; fHitRate = fHitRate + 0.101f)
        {
            int32_t nRealHitCount = 0;
            float fRealHitRate = 0;

            // std::rand测试
            RandomHitTest(nTotalCount, fHitRate, 1, nRealHitCount, fRealHitRate);
            //std::cout << "AlgorithmType=" << 1 << ",TotlaCount=" << nTotalCount << ",HitRate=" << 
            
//    fHitRate  << ",ReahHitRate=" << std::fixed << fRealHitRate << ",RealHitCount=" << nRealHitCount << std::endl;


            int32_t nRealHitCount1 = 0;
            float fRealHitRate1 = 0;

            // cpp11 mt19937
            RandomHitTest(nTotalCount, fHitRate, 2, nRealHitCount1, fRealHitRate1);
            //std::cout << "AlgorithmType=" << 2 << ",TotlaCount=" << nTotalCount << ",HitRate=" << 
            
//    fHitRate  << ",ReahHitRate=" << std::fixed << fRealHitRate1 << ",RealHitCount=" << nRealHitCount1 << std::endl;
            
//std::cout << "---differ rate=" << std::fixed << fRealHitRate1 - fRealHitRate << ", differ count=" 
            
//    << nRealHitCount1 - nRealHitCount << std::endl;

            std::tuple<floatfloat> tupleResult = std::make_tuple(fHitRate, std::fabsf(fRealHitRate1 - fRealHitRate));
            vecResult.push_back(tupleResult);
        }
    }

    std::sort(vecResult.begin(), vecResult.end(), 
        [](std::tuple<floatfloat>& tupLeft, std::tuple<floatfloat>& tupRight)->bool{
            //float fHitRateL = 0;
            
//float fRealRateL = 0;

            
//float fHitRateR = 0;
            
//float fRealRateR = 0;
            return std::get<1>(tupLeft) - std::get<1>(tupRight) > 0;;
    });

    auto tupleFirst = vecResult[0];

    return 0;
}


uint32_t StdRandEx(uint32_t nMin, uint32_t nMax)
{
    XASSERT((nMin >= 0) && (nMax >= 0) && (nMin <= nMax));

    uint32_t nRandVal = 0;

    if (nMin == nMax)
    {
        nRandVal = nMax;
    }
    else if (nMin < nMax)
    {
        nRandVal = rand() % (nMax - nMin + 1) + nMin;
    }
    else
    {
        XASSERT_MSG(0, _T("参数异常"));
    }

    return nRandVal;
}

void RandomHitTest_std_rand(int32_t nTotalCount, float fHitRate, int32_t& nRealHitCount, float& fRealHitRate)
{
    nRealHitCount = 0;
    fRealHitRate = 0;

    if (nTotalCount <= 0 || fHitRate <= 0)
    {
        return;
    }

    // 计算浮点小数点个数
    int32_t nWeCount = 3;  // 位数(三位数,千分比精度)
    XASSERT((fHitRate * std::pow(10, nWeCount)) - std::numeric_limits<uint64_t>::max() <= X_DEFAULT_FLOAT_PRECISION);  // 永不溢出
    int64_t nHitRateIntHelp = static_cast<uint64_t>(fHitRate * std::pow(10, nWeCount));  // 概率转整数辅助计算

    
// 根据位数决定随机数范围
    int32_t nRandMin = 0;
    int32_t nRandMax = std::pow(10, nWeCount);

    // 开始测试
    auto nTestCount = nTotalCount;
    while (nTestCount-- > 0)
    {
        // 生成随机数
        int32_t nRandVal = StdRandEx(nRandMin, nRandMax);

        // 命中判定
        if (nRandVal < nHitRateIntHelp)
        {
            nRealHitCount++;
        }
    }

    fRealHitRate = float(nRealHitCount)/float(nTotalCount);
}

void RandomHitTest_std_mt19937(int32_t nTotalCount, float fHitRate, int32_t& nRealHitCount, float& fRealHitRate)
{
    nRealHitCount = 0;
    fRealHitRate = 0;

    if (nTotalCount <= 0 || fHitRate <= 0)
    {
        return;
    }

    // 计算浮点小数点个数
    int32_t nWeCount = 3;  // 位数(三位数,千分比精度)
    XASSERT((fHitRate * std::pow(10, nWeCount)) - std::numeric_limits<uint64_t>::max() <= X_DEFAULT_FLOAT_PRECISION);  // 永不溢出
    int64_t nHitRateIntHelp = static_cast<uint64_t>(fHitRate * std::pow(10, nWeCount));  // 概率转整数辅助计算

    
// 根据位数决定随机数范围
    int32_t nRandMin = 0;
    int32_t nRandMax = std::pow(10, nWeCount);

    // 设置随机数生成器
    std::random_device rd;
    std::mt19937_64 gen(rd());
    std::uniform_int_distribution<> dis(nRandMin, nRandMax);
    
    // 重设种子应该使用这个api:::CryptGenRandom
    
// linux也有相应的高精度随机数
    gen.seed(uint32_t(time(NULL)));

    // 开始命中测试
    auto nTestCount = nTotalCount;
    while (nTestCount-- > 0)
    {
        // 生成随机数
        uint32_t randVal = dis(gen);

        if (randVal < nHitRateIntHelp)
        {
            nRealHitCount++;
        }
    }

    fRealHitRate = float(nRealHitCount)/float(nTotalCount);
}


bool RandomHitTest(int32_t nTotalCount, float fHitRate, int32_t nAlgorithmType, int32_t& nRealHitCount, float& fRealHitRate)
{
    if (nTotalCount <= 0)
    {
        return false;
    }

    bool bRet = true;
    switch (nAlgorithmType)
    {
    case 1:
        RandomHitTest_std_rand(nTotalCount, fHitRate, nRealHitCount, fRealHitRate);
        break;
    case 2:
        RandomHitTest_std_mt19937(nTotalCount, fHitRate, nRealHitCount, fRealHitRate);
        break;
    default:
        bRet = false;
        break;
    }

    return true;
}

posted @ 2017-01-22 12:28 Enic 阅读(241) | 评论 (0)编辑 收藏

参考链接:http://www.cnblogs.com/dolphinX/p/3269145.html
最基础的玩法:

var Plaza = {};
Plaza.HelloWorldLayer = cc.Layer

这样解决不了多个文件中需要使用同一个名字控件而且需要共享的情况。


var Plaza = Plaza || {};
Plaza.HelloWorldLayer = cc.Layer
这样简单处理能搞定。

另外还有如下比较高阶的函数玩法:

(function(){                 
   var _NS=function(){ }
   _NS.prototype.alert
=function(){
      console.log(
'test');
}
window.NS
=new _NS();
})();
posted @ 2016-12-21 10:15 Enic 阅读(17) | 评论 (0)编辑 收藏

bSceneCutsomResolution决定适配策略ResolutionPolicy::EXACT_FIT会用缩放拉伸的方式适配

void
 CAutoScreen::SetSceneResolute(float w, float h, bool bSceneCutsomResolution)
{
    CAutoScreen::sceneCutsomResolution=bSceneCutsomResolution;

    if(bSceneCutsomResolution)
    {
        cocos2d::Size ls = Size(w, h);
        Size fs = Director::getInstance()->getOpenGLView()->getFrameSize();
        float sx = ls.width/fs.width;
        float sy = ls.height/fs.height;
    
        sceneResolute = ls;
    
        //定义 scale 变量
        resoluteBool = sx>sy;
        float scale = resoluteBool?sx:sy;
        SetSceneSize(resoluteBool?ls.width:fs.width*scale, resoluteBool?fs.height*scale:ls.height);
        SetSceneScale(resoluteBool?fs.height*scale/ls.height : fs.width*scale/ls.width);
    
        Director::getInstance()->getOpenGLView()->setDesignResolutionSize(GetSceneWidth(), GetSceneHeight(), ResolutionPolicy::SHOW_ALL);
    }
    else
    {
        sceneScale = 0.0f;
        sceneSize = Size(w, h);
        sceneResolute = Size(w, h);
        Director::getInstance()->getOpenGLView()->setDesignResolutionSize(w, h, ResolutionPolicy::EXACT_FIT);
    }
    Director::getInstance()->setContentScaleFactor(1.0f);
}
posted @ 2016-12-19 18:07 Enic 阅读(65) | 评论 (0)编辑 收藏

1.暴力做法:
select * into [QPTreasureDB].dbo.[WinLoseScoreInfo2] from [QPTreasureDB].dbo.[WinLoseScoreInfo]
drop table [WinLoseScoreInfo]
select distinct * into [QPTreasureDB].dbo.[WinLoseScoreInfo] from [WinLoseScoreInfo2]

2.如果表中有id字段可以考虑:先根据指定字段查询重复数据,然后根据不为已的id设置保留数据
select UserId, ServerId, DateId, count(*) as [count], @@rowid--, ROW_NUMBER()over(order by UserId, ServerId, DateId) 
from QPTreasureDB.dbo.WinLoseScoreInfo 
group by UserId, ServerId, DateId 
having count(*) > 1;
posted @ 2016-12-19 13:58 Enic 阅读(12) | 评论 (0)编辑 收藏

仅列出标题
共22页: 1 2 3 4 5 6 7 8 9 Last