C++博客- C++ 技术中心-随笔分类-C++ 基础

golang游戏服务器引擎

C++技术中心 — Thu, 07 May 2020 08:04:00 GMT

现在go语言比较流行的有leaf,gowold,origin。前两个比较基础，实现集群还需要进行二次的编码设计。origin不一样，只需要通过配置方便快速的集群。origin总体设计如go语言设计一样，总是尽可能的提供简洁和易用的模式，快速开发。能够根据业务需求快速并灵活的制定服务器架构。利用多核优势，将不同的service配置到不同的node，并能高效的协同工作。将整个引擎抽象三大对象，node,service,module。通过统一的组合模型管理游戏中各功能模块的关系。

origin引擎三大对象关系

---------------

* Node: 可以认为每一个Node代表着一个origin进程

* Service:一个独立的服务可以认为是一个大的功能模块，他是Node的子集，创建完成并安装Node对象中。服务可以支持对外部RPC等功能。

* Module: 这是origin最小对象单元，强烈建议所有的业务模块都划分成各个小的Module组合，origin引擎将监控所有服务与Module运行状态，例如可以监控它们的慢处理和死循环函数。Module可以建立树状关系。Service本身也是Module的类型。

更加详细的参照项目地址：https://github.com/duanhf2012/origin

C++技术中心 2020-05-07 16:04 发表评论

内存泄露监控报告

C++技术中心 — Tue, 21 Nov 2017 09:28:00 GMT

时间总是能让一切改变，至上次发blog我已经不在福州。现在就职于成都一家公司，刚来一直在阅读代码，发现服务器的逻辑代码，有挺多让直接new申请内存，对这个我总觉得有些裸奔的感觉。啊哈，有可能被同事看到，我没有其他意思哈，只是觉得没有管理，一不小心就内存泄露了，写的时候要小心又小心。如果要从堆中获取一块内存，一般还是交给智能指针去管理更妥些。
以上这大段和下面写的都没有任何关系。嗯，是的，确实是没有关系，我只是在思考已经这样写了，能不能对内存申请和释放做个监控。其实网上代码一堆，我也自己按照自己的思路实现了一下，原理都是重载new和delete方式了。闲言少叙，话不多说。
同样，我也要重载new与delete关键字，但是我重载的是带3参数的，具体的申请交给我的CMemLeakMonitorMgr管理器吧。以后再具体说明，先看如下代码：

void* operator new(size_t size, const char* funName, size_t line)
{
    return g_pMemLeakMonitorMgr.Alloc(funName,line,size);
}
void* operator new[](size_t size, const char* file, int line)
{
    return operator new(size, file, line);
}

void* operator new(size_t size)
{
    return malloc(size);
}
void* operator new[](size_t size)
{
    return malloc(size);
}

void* operator new(size_t size, const std::nothrow_t&) throw()
{
    return ::operator new(size);
}
void* operator new[](size_t size, const std::nothrow_t&) throw()
{
    return ::operator new[](size);
}

void  operator delete(void* p)
{
    return g_pMemLeakMonitorMgr.Free(p);
}

然后我定义以下宏，来替换new操作,请看下面：

#define DEBUG
#ifdef DEBUG
#define DEBUG_NEW new(__FUNCTION__, __LINE__)
#define DEBUG_DELETE(p) delete p
#else
#define DEBUG_NEW new
#define DEBUG_DELETE(p) delete p
#endif

上面的宏应该不用多说吧，设计的是只有在debug情况下，才会生效。这里用DEBUG_NEW与DEBUG_DELETE宏来申请和释放内存，其实完全可以直接替换new与delete，但是我不想这么做，因为我想在使用者用该宏时明白它做了一些“见不得人”的事情。哈，还是那句话闲言少叙，废话不能多。看下怎么使用吧：

void fun1()
{
    DEBUG_NEW int;
}

void fun2()
{
    char *p = DEBUG_NEW char;
    DEBUG_DELETE(p);
}

void fun3()
{
    DEBUG_NEW int;
}

int main()
{
    Test2 *p = DEBUG_NEW Test2();
    DEBUG_DELETE(p);

    fun1();
    fun2();
    fun3();
    fun1();
    fun1();

    g_pMemLeakMonitorMgr.ReportMemLeak();
    return 0;
}

嗯，是的，这个很好懂，通过宏来替换之前的new和delete，然后几个函数中有些函数是有内存泄露的。然后通过ReportMemLeak来报告结果。可以显示的如下：

Test2 constructor.

Test2 destructor.

Test2 constructor.

Test2 destructor.

Memory leak FunName:fun1,line:182,totalsize:12 bytes.

Memory leak FunName:fun3,line:194,totalsize:4 bytes.

C++技术中心 2017-11-21 17:28 发表评论

vc内存地址填充

C++技术中心 — Thu, 06 Jul 2017 03:33:00 GMT

0xcdcdcdcd - Created but not initialised

0xdddddddd - Deleted
0xfeeefeee - Freed memory set by NT's heap manager
0xcccccccc - Uninitialized locals in VC6 when you compile w/ /GZ
0xabababab - Memory following a block allocated by LocalAlloc()

VC++在Debug编译方式编译的程序中，会跟踪用new分配的内存。新分配的内存会用0xcd(助记词为Cleared Data)填充，防止未初始化；当它被delete后，又会被0xdd(Dead Data)填充，防止再次被使用。这样有利于调试内存错误。之所以选这样的填充模式，是因为：

1.大数，若被当成指针就会越界

2.奇数，指针通常指向偶数地址

3.非0,这样不会和 NULL 混淆。

在Release版中不会有这些字节填充。

C++技术中心 2017-07-06 11:33 发表评论

c++函数throw()

C++技术中心 — Fri, 30 Jun 2017 08:28:00 GMT

#define _NOEXCEPT throw ()
shared_ptr<_Ty> lock() const _NOEXCEPT

它是函数提供者和使用者的一种君子协定，标明该函数不抛出任何异常。

之所以说是君子协定，是因为实际上内部实现是需要人肉确保。

如果一个标明throw()的函数内部发生了throw：

1，如果内部直接throw something，编译器会发现并指出；

2. 如果是内部调用了一个可能throw something的函数，编译器无法发现，运行时一旦这个内部的函数throw，程序会abort。

****

func() throw(type) ,会抛出某种异常

func() throw(),不会抛出

func() throw(...)，可能是任何类型的异常

C++技术中心 2017-06-30 16:28 发表评论

C/C++中volatile与 mutable,explicit 关键字详解

C++技术中心 — Thu, 13 Apr 2017 05:39:00 GMT

C/C++ 中的 volatile 关键字和 const 对应，用来修饰变量，通常用于建立语言级别的 memory barrier。这是 BS 在 "The C++ Programming Language" 对 volatile 修饰词的说明：

A volatile specifier is a hint to a compiler that an object may change its value in ways not specified by the language so that aggressive optimizations must be avoided.

volatile 关键字是一种类型修饰符，用它声明的类型变量表示可以被某些编译器未知的因素更改，比如：操作系统、硬件或者其它线程等。遇到这个关键字声明的变量，编译器对访问该变量的代码就不再进行优化，从而可以提供对特殊地址的稳定访问。声明时语法：int volatile vInt; 当要求使用 volatile 声明的变量的值的时候，系统总是重新从它所在的内存读取数据，即使它前面的指令刚刚从该处读取过数据。而且读取的数据立刻被保存。例如：

1 volatile int i=10;

2 int a = i;

3 ...

4 // 其他代码，并未明确告诉编译器，对 i 进行过操作

5 int b = i;

volatile 指出 i 是随时可能发生变化的，每次使用它的时候必须从 i的地址中读取，因而编译器生成的汇编代码会重新从i的地址读取数据放在 b 中。而优化做法是，由于编译器发现两次从 i读数据的代码之间的代码没有对 i 进行过操作，它会自动把上次读的数据放在 b 中。而不是重新从 i 里面读。这样以来，如果 i是一个寄存器变量或者表示一个端口数据就容易出错，所以说 volatile 可以保证对特殊地址的稳定访问。注意，在 VC 6 中，一般调试模式没有进行代码优化，所以这个关键字的作用看不出来。下面通过插入汇编代码，测试有无 volatile 关键字，对程序最终代码的影响：

输入下面的代码：

01 #include

03 void main()

04 {

05 int i = 10;

06 int a = i;

08 printf("i = %d", a);

10 // 下面汇编语句的作用就是改变内存中 i 的值

11 // 但是又不让编译器知道

12 __asm {

13 mov dword ptr [ebp-4], 20h

14 }

16 int b = i;

17 printf("i = %d", b);

18 }

然后，在 Debug 版本模式运行程序，输出结果如下：

i = 10

i = 32

然后，在 Release 版本模式运行程序，输出结果如下：

i = 10

输出的结果明显表明，Release 模式下，编译器对代码进行了优化，第二次没有输出正确的 i 值。下面，我们把 i 的声明加上 volatile 关键字，看看有什么变化：

01 #include

03 void main()

04 {

05 volatile int i = 10;

06 int a = i;

08 printf("i = %d", a);

09 __asm {

10 mov dword ptr [ebp-4], 20h

11 }

13 int b = i;

14 printf("i = %d", b);

15 }

分别在 Debug 和 Release 版本运行程序，输出都是：

i = 10

i = 32

这说明这个 volatile 关键字发挥了它的作用。其实不只是“内嵌汇编操纵栈”这种方式属于编译无法识别的变量改变，另外更多的可能是多线程并发访问共享变量时，一个线程改变了变量的值，怎样让改变后的值对其它线程 visible。一般说来，volatile用在如下的几个地方：

1) 中断服务程序中修改的供其它程序检测的变量需要加volatile；

2) 多任务环境下各任务间共享的标志应该加volatile；

3) 存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；

2.volatile 指针

和 const 修饰词类似，const 有常量指针和指针常量的说法，volatile 也有相应的概念：

修饰由指针指向的对象、数据是 const 或 volatile 的：

1 const char* cpch;

2 volatile char* vpch;

注意：对于 VC，这个特性实现在 VC 8 之后才是安全的。

指针自身的值——一个代表地址的整数变量，是 const 或 volatile 的：

1 char* const pchc;

2 char* volatile pchv;

注意：(1) 可以把一个非volatile int赋给volatile int，但是不能把非volatile对象赋给一个volatile对象。

　　 (2) 除了基本类型外，对用户定义类型也可以用volatile类型进行修饰。

(3) C++中一个有volatile标识符的类只能访问它接口的子集，一个由类的实现者控制的子集。用户只能用const_cast来获得对类型接口的完全访问。此外，volatile向const一样会从类传递到它的成员。

3. 多线程下的volatile

有些变量是用volatile关键字声明的。当两个线程都要用到某一个变量且该变量的值会被改变时，应该用volatile声明，该关键字的作用是防止优化编译器把变量从内存装入CPU寄存器中。如果变量被装入寄存器，那么两个线程有可能一个使用内存中的变量，一个使用寄存器中的变量，这会造成程序的错误执行。volatile的意思是让编译器每次操作该变量时一定要从内存中真正取出，而不是使用已经存在寄存器中的值，如下：

volatile BOOL bStop = FALSE;

(1) 在一个线程中：

while( !bStop ) { ... }

bStop = FALSE;

return;

(2) 在另外一个线程中，要终止上面的线程循环：

bStop = TRUE;

while( bStop ); //等待上面的线程终止，如果bStop不使用volatile申明，那么这个循环将是一个死循环，因为bStop已经读取到了寄存器中，寄存器中bStop的值永远不会变成FALSE，加上volatile，程序在执行时，每次均从内存中读出bStop的值，就不会死循环了。

这个关键字是用来设定某个对象的存储位置在内存中，而不是寄存器中。因为一般的对象编译器可能会将其的拷贝放在寄存器中用以加快指令的执行速度，例如下段代码中：

...

int nMyCounter = 0;

for(; nMyCounter<100;nMyCounter++)

{

...

}

...

在此段代码中，nMyCounter的拷贝可能存放到某个寄存器中（循环中，对nMyCounter的测试及操作总是对此寄存器中的值进行），但是另外又有段代码执行了这样的操作：nMyCounter -= 1;这个操作中，对nMyCounter的改变是对内存中的nMyCounter进行操作，于是出现了这样一个现象：nMyCounter的改变不同步。

C++技术中心 2017-04-13 13:39 发表评论

使用enable_shared_from_this(转)

C++技术中心 — Tue, 07 Mar 2017 06:17:00 GMT

使用enable_shared_from_this

说明
The header defines the class template enable_shared_from_this. It is used as a base class that allows a shared_ptr to the current object to be obtained from within a member function.
继承该类就可以进行基于当前子类进行安全的weap_ptr到shared_ptr的转换...

代码实例
以下代码中Y类继承enable_shared_from_this,, 从而我们可以直接在函数中调用shared_from_this获得该对象的shared_ptr

class Y: public enable_shared_from_this { public: shared_ptr f() { return shared_from_this(); } } int main() { shared_ptr p(new Y); // 调用f获得shared_ptr shared_ptr q = p->f(); assert(p == q); assert(!(p < q || q < p)); // p and q must share ownership }

该类的实现

template class enable_shared_from_this { protected: enable_shared_from_this() { } enable_shared_from_this(enable_shared_from_this const &) { } enable_shared_from_this & operator=(enable_shared_from_this const &) { return *this; } ~enable_shared_from_this() { } public: shared_ptr shared_from_this() { shared_ptr p(_internal_weak_this); BOOST_ASSERT(p.get() == this); return p; } shared_ptr shared_from_this() const { shared_ptr p(_internal_weak_this); BOOST_ASSERT(p.get() == this); return p; } // Note: No, you don't need to initialize _internal_weak_this // // Please read the documentation, not the code // // http://www.boost.org/libs/smart_ptr/enable_shared_from_this.html typedef T _internal_element_type; // for bcc 5.5.1 mutable weak_ptr<_internal_element_type> _internal_weak_this; };

结论
这个实用类提供了简单的shared_ptr转换和安全的weak式验证... 这样通过继承就可以使用

shared_from_this进行安全当前类weak_ptr到shared_ptr的转换...

enable_from_this方法的使用与陷阱
enable_from_this 的使用与实现原理说明：
shared_from_this()是enable_shared_from_this的成员函数，返回shared_ptr;
注意的是，这个函数仅在shared_ptr的构造函数被调用之后才能使用。
原因是enable_shared_from_this::weak_ptr并不在构造函数中设置，而是在shared_ptr的构造函数中设置。
错误的使用代码一：
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
        boost::shared_ptr<D> p = shared_from_this();
    }    
};

int main()
{
    boost::shared_ptr<D> a(new D);
    return 0;    
}

程序编译通过，执行结果如下：
D::D()
terminate called after throwing an instance of 'boost::exception_detail::clone_impl >'
  what():  tr1::bad_weak_ptr
Aborted
说明在D的构造函数中调用shared_from_this(), 此时D的实例本身尚未构造成功，weak_ptr也就尚未设置,所以程序抛出tr1::bad_weak_ptr异常。
错误的使用代码二：
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
    }
    
    void func()
    {
        cout<<"D::func()"<<endl;
        boost::shared_ptr<D> p = shared_from_this();
    }    
};

int main()
{
    D d;
    d.func();
    return 0;    
}

程序编译通过，执行结果如下：
D::D()
D::func()
terminate called after throwing an instance of 'boost::exception_detail::clone_impl >'
  what():  tr1::bad_weak_ptr
Aborted
失败原因分析：
在主函数main中，D的实例是在栈上构造，没有使用boost::shared_ptr 的构造方式，
所以boost::enable_shared_from_this中的weak_ptr所指的函数对象也就没有被赋值，
在调用d.func()中使用shared_from_this()函数时
----注：shared_from_this的函数实现 ------
    shared_ptr shared_from_this()
    {
        shared_ptr p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }
----注：shared_from_this的函数实现 ------
调用BOOST_ASSERT( p.get() == this );  失败，抛出以上异常。
最后，我们给出share_from_this()的正确使用例子:
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>

#include <iostream>
using namespace std;

class D: public boost::enable_shared_from_this<D>
{
public:
    D()
    {
        cout<<"D::D()"<<endl;
    }
    
    void func()
    {
        cout<<"D::func()"<<endl;
        boost::shared_ptr<D> p = shared_from_this();
    }    
};

int main()
{
    boost::shared_ptr<D> p(new D);
    p->func();
    return 0;    
}    

执行结果:
D::D()
D::func()

C++技术中心 2017-03-07 14:17 发表评论

c++ 11std::bind std::function 高级用法

C++技术中心 — Mon, 13 Jun 2016 07:39:00 GMT

/*
* File:   main.cpp
* Author: Vicky.H
* Email:  eclipser@163.com
*/
#include
#include
#include
#include <string.h>

int add1(int i, int j, int k) {
    return i + j + k;
}

class Utils {
public:
    Utils(const char* name) {
        strcpy(_name, name);
    }

    void sayHello(const char* name) const {
        std::cout << _name << " say: hello " << name << std::endl;
    }

    static int getId() {
        return 10001;
    }

    int operator()(int i, int j, int k) const {
        return i + j + k;
    }

private:
    char _name[32];
};

/*
*
*/
int main(void) {

    // 绑定全局函数
    auto add2 = std::bind(add1, std::placeholders::_1, std::placeholders::_2, 10);
    // 函数add2 = 绑定add1函数，参数1不变，参数2不变，参数3固定为10.
    std::cout << typeid(add2).name() << std::endl;
    std::cout << "add2(1,2) = " << add2(1, 2) << std::endl;

    std::cout << "\n---------------------------" << std::endl;

    // 绑定成员函数
    Utils utils("Vicky");
    auto sayHello = std::bind(&Utils::sayHello, utils/*调用者*/, std::placeholders::_1/*参数1*/);
    sayHello("Jack");

    auto sayHelloToLucy = std::bind(&Utils::sayHello, utils/*调用者*/, "Lucy"/*固定参数1*/);
    sayHelloToLucy();

    // 绑定静态成员函数
    auto getId = std::bind(&Utils::getId);
    std::cout << getId() << std::endl;

    std::cout << "\n---------------------------" << std::endl;

    // 绑定operator函数
    auto add100 = std::bind(&Utils::operator (), utils, std::placeholders::_1, std::placeholders::_2, 100);
    std::cout << "add100(1, 2) = " << add100(1, 2) << std::endl;

    // 注意：无法使用std::bind()绑定一个重载函数

    return 0;
}

/*
* File:   main2.cpp
* Author: Vicky.H
* Email:  eclipser@163.com
*/
#include
#include

void sayHello() {
    std::cout << "Hello world !" << std::endl;
}

int sum(int i, int j, int k) {
    return i + j + k;
}

template
class Func {
public:

    Func(T fun) {
        if (!fun) {
            throw "fun nullptr";
        }
        _fun = fun;
    }

    template
    R Call(A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) {
        return _fun(a1, a2, a3, a4, a5);
    }

    template
    R Call(A1 a1, A2 a2, A3 a3, A4 a4) {
        return _fun(a1, a2, a3, a4);
    }

    template
    R Call(A1 a1, A2 a2, A3 a3) {
        return _fun(a1, a2, a3);
    }

    template
    R Call(A1 a1, A2 a2) {
        return _fun(a1, a2);
    }

    template
    R Call(A1 a1) {
        return _fun(a1);
    }

    template
    R Call() {
        return _fun();
    }

    void Call() {
        _fun();
    }

private:
    T _fun;
};

#include

templatevoid, typename Args>
class Fn {
public:
    Fn(std::function fun) : _fun(fun) {
    }

    R operator()(Args args) {
        return _fun(args);
    }
private:
    std::function _fun;
};

/*
* 将函数注册到对象中，通过对象直接调用
*/
int main(void) {

    Func<void(*)() > sayHelloFunc(sayHello);
    sayHelloFunc.Call();

    Func<int (*)(int, int, int) > sumFunc(sum);
    std::cout << "sumFunc.Call(1, 2, 3) : " << sumFunc.Call<int>(1, 2, 3) << std::endl;

    std::cout << "\n---------------------------" << std::endl;

    Fn<> sayHelloFn(sayHello);
    sayHelloFn();

    Fn<int, int, int, int> sumFn(sum);
    std::cout << "sumFn(1, 2, 3) : " << sumFn(1, 2, 3) << std::endl;

    std::cout << "\n---------------------------" << std::endl;

    return 0;
}

Hello world !
sumFunc.Call(1, 2, 3) : 6

---------------------------
Hello world !
sumFn(1, 2, 3) : 6

---------------------------

上面的例子非常有趣，使用了2种方案，将一个函数，注册到一个对象/仿函数中，并且通过一个对象/仿函数来直接调用调用。
例子显而易见的，第2种方案更佳简洁，并且对传递参数有明确的判断，当参数类型或数量不正确的时候，编译器将导致失败。
这种方案，可以将类的成员变量直接作为函数的参数使用，或者，如我：
http://blog.csdn.net/eclipser1987/article/details/23926395
这篇文章中，无法直接调用脚本函数类，有了好的解决办法。这个我将随后补充。

#include
#include

template
class Fns
{
private:

    std::listvoid(Args)> > _calls;

public:

    virtual ~Fns()
    {
        _calls.clear();
    }

    void connect(std::function<void(Args)> fct)
    {
        _calls.push_back(fct);
    }

    template
    void connect(Object* object, void (Object::*method)(Args))
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    template
    void connect(Object* object, void (Object::*method)(Args) const)
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    template
    void connect(const Object* object, void (Object::*method)(Args) const)
    {
        _calls.push_back([object,method](Args args){(*object.*method)(args);});
    }

    void emit(Args args)
    {
        for(auto call : _calls)
            call(args);
    }
};

#include
#include "Signal.hpp"

class Foo
{
public:

    void bar(int x, int y)
    {
        printf("Foo::bar(%d, %d)\n", x, y);
    }
};

void foobar(int x, int y)
{
    printf("foobar(%d, %d)\n", x, y);
}

int main(void)
{
    Foo foo;
    Fns<int, int> s;

    // Connect a function
    s.connect(foobar);
    // Connect a class method
    s.connect(&foo, &Foo::bar);
    // Create and connect some lambda expression
    s.connect([&foo](int x, int y){
        printf("lambda::"); foo.bar(x, y);
    });
    // Emit the signal !
    s.emit(4, 2);
    getchar();
    return 0;
}

foobar(4, 2)
Foo::bar(4, 2)
lambda::Foo::bar(4, 2)

C++技术中心 2016-06-13 15:39 发表评论

10个C++11特性

C++技术中心 — Wed, 02 Dec 2015 02:16:00 GMT

摘要: 在C++11之前，auto关键字用来指定存储期。在新标准中，它的功能变为类型推断。auto现在成了一个类型的占位符，通知编译器去根据初始化代码推断所声明变量的真实类型。各种作用域内声明变量都可以用到它。例如，名空间中，程序块中，或是for循环的初始化语句中。?123auto i = 42; &nb... 阅读全文

C++技术中心 2015-12-02 10:16 发表评论

C++中的explicit关键字

C++技术中心 — Mon, 24 Nov 2014 06:34:00 GMT

在C++程序中很少有人去使用explicit关键字，不可否认，在平时的实践中确实很少能用的上。再说C++的功能强大，往往一个问题可以利用好几种C++特性去解决。但稍微留心一下就会发现现有的MFC库或者C++标准库中的相关类声明中explicit出现的频率是很高的。了解explicit关键字的功能及其使用对于我们阅读使用库是很有帮助的，而且在编写自己的代码时也可以尝试使用。既然C++语言提供这种特性，我想在有些时候这种特性将会非常有用。

按默认规定，只用传一个参数的构造函数也定义了一个隐式转换。举个例子：

（下面这个CExample没有什么实际的意义，主要是用来说明问题）

//Example.h

#pragma once

class CExample

{

public:

CExample(void);

public:

~CExample(void);

public:

int m_iFirst;

int m_iSecond;

public:

CExample(int iFirst, int iSecond = 4);

};

//Example.cpp

#include "StdAfx.h"

#include "Example.h"

CExample::CExample(void)

: m_iFirst(0)

{

}

CExample::~CExample(void)

{

}

CExample::CExample(int iFirst, int iSecond):m_iFirst(iFirst), m_iSecond(iSecond)

{

}

//TestExplicitKey.cpp

...//其它头文件

#include "Example.h"

int _tmain(int argc, _TCHAR* argv[])

{

CExample objOne; //调用没有参数的构造函数

CExample objTwo(12, 12); //调用有两个参数的构造函数

CExample objThree(12); //同上，可以传一个参数是因为该构造函数的第二个参数有默认值

CExample objFour = 12; //执行了隐式转换,等价于CExample temp(12);objFour(temp);注意这个地方调用了

//编译器为我们提供的默认复制构造函数

return 0;

}

如果在构造函数声明中加入关键字explicit，如下

explicit CExample(int iFirst, int iSecond = 4);

那么CExample objFour = 12; 这条语句将不能通过编译。在vs05下的编译错误提示如下

error C2440: 'initializing' : cannot convert from 'int' to 'CExample'

Constructor for class 'CExample' is declared 'explicit'

对于某些类型，这一情况非常理想。但在大部分情况中，隐式转换却容易导致错误（不是语法错误，编译器不会报错）。隐式转换总是在我们没有察觉的情况下悄悄发生，除非有心所为，隐式转换常常是我们所不希望发生的。通过将构造函数声明为explicit（显式）的方式可以抑制隐式转换。也就是说，explicit构造函数必须显式调用。

引用一下Bjarne Stroustrup的例子:

class String{

explicit String(int n);

String(const char *p);

};

String s1 = 'a'; //错误：不能做隐式char->String转换

String s2(10); //可以：调用explicit String(int n);

String s3 = String(10);//可以：调用explicit String(int n);再调用默认的复制构造函数

String s4 = "Brian"; //可以：隐式转换调用String(const char *p);再调用默认的复制构造函数

String s5("Fawlty"); //可以：正常调用String(const char *p);

void f(String);

String g()

{

f(10); //错误：不能做隐式int->String转换

f("Arthur"); //可以：隐式转换，等价于f(String("Arthur"));

return 10; //同上

}

在实际代码中的东西可不像这种故意造出的例子。

发生隐式转换，除非有心利用，隐式转换常常带来程序逻辑的错误，而且这种错误一旦发生是很难察觉的。

原则上应该在所有的构造函数前加explicit关键字，当你有心利用隐式转换的时候再去解除explicit，这样可以大大减少错误的发生。

C++技术中心 2014-11-24 14:34 发表评论

c++基础要点(9-15点)

C++技术中心 — Fri, 14 Nov 2014 06:00:00 GMT

9. 若不想使用编译器自动生成的函数，就该明确的拒绝

#include "stdafx.h"
#include <string>

using namespace  std;

class UnCopyAble
{
protected:
    UnCopyAble(){}
    ~UnCopyAble(){}

private:
    //放入private，则不允许使用拷贝构造和对象间赋值
    //即使不慎在 membre或friend中使用，则链接通不过。
    //原因是只有声明
    UnCopyAble(const UnCopyAble&);
    UnCopyAble& operator=(const UnCopyAble &);
};

class HomeForSale : private UnCopyAble //class 不再声明copy构造函数和赋值重载
{
public:

};

int _tmain(int argc, _TCHAR* argv[])
{
    HomeForSale sale1;


    //以下将不允许
    HomeForSale sale2(sale1);

    //以下将不允许
    HomeForSale sale3;
    sale3 = sale1;
    return 0;
}

10.为多态基类声明virtual析构函数

总结：带有多态性质的基类应该声明一个virtual析构函数。如果class带有任何virutal，它也应该拥有一个virtual析构函数。
class设计目的不是作为基类来使用的，或不是为了具备多态性，就不应该声明virutal析构函数(一个类如果加入了virutal函数，则类大小
会发生变化。因为有包含virutal table pointer)。

11. 别让异常逃离析构函数
析构函数绝对不要吐出异常，这样会带来“过早结束程序”或“发生不明确行为”。如果一个析构函数可能要抛出异常，析构函数应该捕捉任何异常，然后吞下
它，或者结束程序。如果要在某个函数运行时抛出的异常做出反应，那么class应该提供一个普通函数执行这个操作。例如下：

class DBConn
{
public:

    //供客户使用的函数
    void Close()
    {
        db.close();
        closed = true;
    }

    ~DBConn()
    {
        if(!closed)
        {
            try
            {
                db.close(); //关闭连接，如果客户不调用Close的话
            }
            catch ()
            {
                //写入日志，记下close调用失败
            }
        }
    }

private:
    DBConnection db;
    bool closed;

12. 绝不在构造和析构过程中调用virtual函数

// testss.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <string>
#include

using namespace  std;

class Transaction
{
public:
    Transaction();
    void init();
    virtual void logTranscation() = 0;

};

Transaction::Transaction()
{
    init();
}

void Transaction::init()
{
    logTranscation();
}

class BuyTransaction : public Transaction
{
public:
    void logTranscation()
    {
        printf("BuyTransaction log\n");
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    BuyTransaction b;
    return 0;
}

以上代码，会有一个BuyTransaction构造函数被调用，但首先是Transaction更早被调用。在derived class对象的base class构造期间，对象的类型是base class.若使用运行期类型信息，也会把对象视为base class类型。本例，构造函数中调用init,而init中调用Transaction::logTransaction。而logTransaction又是抽象方法，导致程序异常中止。当然如果非抽象方法，则会调用Transaction中的logTransaction。

同样，析构函数，一旦derived class析构函数先开始执行。对象内的derived class成员变量便呈现现未定义值。所以c++视它们不存在。进入base class析构函数后对象就成为一个base class对象。

13. 令operator=返回一个reference to *this
14. 在operator=中处理“自我赋值”

C++技术中心 2014-11-14 14:00 发表评论

c++基础要点(1-8点)

C++技术中心 — Fri, 14 Nov 2014 05:29:00 GMT

// testss.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <string>

using namespace  std;
char& testfun(char &m)
{
    return m;
}

class CTextBlock
{
public:
    int length() const;

    const char &operator[](int pos) const
    {
       //其他代码
        return pText[pos];
    }

    char& operator[](int pos)
    {
        return const_cast<char&>( static_cast<const CTextBlock>(*this)[pos]  );
    }
private:
    char *pText;
    mutable int textLength; //
    mutable bool lengthIsValid;
};

int CTextBlock::length() const
{
    if(!lengthIsValid)
    {
        textLength = strlen(pText);
        lengthIsValid = true;
    }

    return textLength;
}

template<class T>
class NameObject{
public:
    NameObject(string &name,const T&value):nameValue(name),objectValue(value)
    {

    }

private:
    std::string &nameValue;
    const T objectValue;
};

int _tmain(int argc, _TCHAR* argv[])
{

    //1.const位置使用
    //以下a1,a2等同
    const int a1 = 10;
    int const a2=10;

    //以下b1,b2等同
    int const *b1 = NULL;
    const int *b2 = NULL;

    //指针c不允许改变
    int * const c = NULL;

    //2.返回引用问题
    //必需返回char &，否则返回char则不能被赋值
    char m = 'a';
    testfun(m) = 'p';

    //3.mutable(可变的)
    const CTextBlock textBlock;
    //在length中用mutable修饰textLength和lengthIsValid，
    //所以const函数length才可以访问非const成员变量
    textBlock.length();


    //4.调用非const[]时，调用const类型的[]重载
    //详细请参见[]重载
    const char& pChar=textBlock[0];
    CTextBlock textBlock2;
    char& tChar = textBlock2[0];

    //5.类的成员，尽可能的使用初始化列表一一初始化,
    //比赋值效率更高，也可以预防不明确行为的潘多拉盒子
    //父类比子类先初始化，类成员初始化顺序是按变量声明的顺序，
    //即使初始化成员列表用其他顺序。

    //6.为避免“跨编译单元之初始化次序”问题，请以local static对象替换
    //non-local的static对象(local static即函数内的,其他的称为non-local static)
    //例如，单件返回static 对象引用的方法

    //7.编译器自动生成构造函数，拷贝构造，=运算符重载，非virtual的析构函数。
    //如果有编写构造函数时，编译器不会自动生成默认构造和拷贝构造函数。同样定义
    //拷贝构造也不会生成默认构造函数，但会生成=,析构函数（但在有被使用的时候才会生成）

    //8.编译器自动生成“=”运算符重载时的特殊问题
    string newDog("persephone");
    string oldDog("stach");
    NameObject<int> p(newDog,2);
    NameObject<int> s(oldDog,36);

    //以下这种情况编译器是不会自动生成赋值“=”构造的,原因是
    //在一个内含引用成员的或const成员时，编译器不知道如何自动生成
    //赋值函数内的实现。还有一种情况是，如果将父类"="函数定义为private
    //编译器同样在子类中不会自动生成赋值函数。
    p = s;//该行语法错误

    return 0;
}

C++技术中心 2014-11-14 13:29 发表评论

_set_invalid_parameter_handler异常处理函数

C++技术中心 — Sat, 13 Sep 2014 02:33:00 GMT

VS2005之后的版本，微软增加了一些新的异常机制，新机制在出现错误时默认不通知应用程序，这时程序就崩溃了。
所以这种情况下，必须调用_set_invalid_parameter_handler、_set_purecall_handler设置自己的异常处理函数。

以下示例代码：

// test.cpp
// compile with: /Zi /MTd
// C++ Exceptions : /EHa

#include
#include

void myInvalidParameterHandler(const wchar_t* expression,
          const wchar_t* function,
          const wchar_t* file,
          unsigned int line,
          uintptr_t pReserved)
{
// function、file、line在Release下无效
wprintf(L"Invalid parameter detected in function %s."
  L" File: %s Line: %d\n", function, file, line);
wprintf(L"Expression: %s\n", expression);
// 必须抛出异常，否则无法定位错误位置
throw 1;
}
void myPurecallHandler(void)
{
printf("In _purecall_handler.");
// 必须抛出异常，否则无法定位错误位置
throw 1;
}

int main()
{
char* formatString;
_invalid_parameter_handler oldHandler;
_purecall_handler old_pure_handle;

oldHandler = _set_invalid_parameter_handler(myInvalidParameterHandler);
old_pure_handle = _set_purecall_handler(myPurecallHandler);

try
{
  formatString = NULL;
  printf(formatString);  // 发生异常
}
catch(...)
{
  // 定位错误位置，输出log
  printf("catch");
}

getchar();
}

说明：
1、由于formatString是空指针，printf(formatString)发生异常，这时CRT会调用myInvalidParameterHandler进行处理；
2、myInvalidParameterHandler抛出异常。注意，function、file、line在Release下无效，所以必须抛出异常，否则无法定位错误代码；
3、设置工程选项C++ Exceptions : /EHa，让catch抓住myInvalidParameterHandler抛出的异常，再做相应的处理；

注意：如果myInvalidParameterHandler不抛出异常，那程序会往下执行，那么可能会发生更糟糕的情况。因此，建议抛出异常，中止执行后续的代码。

C++技术中心 2014-09-13 10:33 发表评论

可变参数

C++技术中心 — Mon, 19 Aug 2013 03:03:00 GMT

几天前，在CSDN论坛看到这么一则讨论：在宏定义中怎么使用可变参数？(http://expert.csdn.net/Expert/topic/2925/2925165.xml)。楼主希望能定义这样的macro：

#define fun1(a, b, ...) fun2(__FILE__, __LINE__, a, b, ...)

我猜楼主是想写trace，如果不能使用可变参数的macro，那么就得像MFC那样写一堆TRACE macros：

// 取自 MFC 7.1 的 afx.h
// The following trace macros are provided for backward compatiblity
// (they also take a fixed number of parameters which provides
// some amount of extra error checking)
#define TRACE0(sz) TRACE(_T("%s"), _T(sz))
#define TRACE1(sz, p1) TRACE(_T(sz), p1)
#define TRACE2(sz, p1, p2) TRACE(_T(sz), p1, p2)
#define TRACE3(sz, p1, p2, p3) TRACE(_T(sz), p1, p2, p3)

太丑陋了！还好，C99标准支持Variadic Macros，在GCC中，可以这么写：

// http://gcc.gnu.org/onlinedocs/gcc/Variadic-Macros.html
#define debug(format, ...) fprintf(stderr, format, __VA_ARGS__)

还可以顺便打印文件名和行号：

#define debug(format, ...) do {/
fprintf(stderr, "%s (%d): ", __FILE__, __LINE__);/
fprintf(stderr, format, __VA_ARGS__);/
} while (0)

但可惜Visual C++ 7.1还不支持这项功能:( 不过我们在C++中至少可以绕弯解决，做到既能自动记录文件名和行号，又能使用变长参数调用。这个办法不是我独创的，实际上ATL的atltrace.h中就有它的实现(CtraceFileAndLineInfo class)，我在Code Project也找到了相同的实现(http://www.codeproject.com/debug/location_trace.asp)，甚至在CUJ的C++ Experts Forum 也能看到相近的做法(http://www.cuj.com/documents/s=8250/cujcexp2106alexandr/)，当然Alexandrescu的办法技巧性更强。

思路：写一个重载了 operator() 的class，令 TRACE 宏返回该class的一个object：

#include
#include

#ifndef NDEBUG // debug mode

class tracer
{
public:
tracer(const char* file, int line)
: file_(file), line_(line)
{}

void operator()(const char* fmt, ...)
{
va_list ap;

// print the file name and line number
fprintf(stderr, "%s (%d): ", file_, line_);

va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);

fprintf(stderr, "/r/n"); // print the new-line character
}

private:
// copy-ctor and operator=
tracer(const tracer&);
tracer& operator=(const tracer&);

private:
const char* file_;
int line_;
};
#define TRACE (tracer(__FILE__, __LINE__))
#else // NDEBUG
#define TRACE (void)
#endif // NDEBUG

int main()
{
#ifndef NDEBUG
tracer(__FILE__, __LINE__)("%x", 123);
#endif

TRACE("%s", "Happy debugging.");
}

这样做是multithreading-safe的。G++ 3.3.1 / Visual C++ 7.1 / Borland C++ 5.5.1 通过。

C++技术中心 2013-08-19 11:03 发表评论

printf函数分别在window和linux打印long long（_int64）

C++技术中心 — Thu, 18 Jul 2013 03:49:00 GMT

首先 Microsoft Visual C++ 6.0 不支持 long long ，支持_int64

printf 输出 long long

在windows 环境下 %I64d

在linux 环境下 %lld

另外打印long long型的函数如下：

void print_bigint(long long n)
{
if (n>=10)
print_bigint(n/10);
printf("%d",int(n%10));
}

C++技术中心 2013-07-18 11:49 发表评论

luaplus介绍

C++技术中心 — Tue, 23 Apr 2013 08:53:00 GMT

摘要: [转载]介绍LuaPlus: 好用的Lua For C++扩展(修订)打算把lua作为项目的脚本语言,下面是不不错的教程,收藏虽然很早前研究过Lua,但还没有在放到项目中进行检验,要亲自用过才知道好坏~LuaPlus是Lua的C++增强，也就是说，LuaPlus本身就是在Lua的源码上进行增强得来的。用它与C++进行合作，是比较好的一个选择。LuaPlus目前版本为：LuaPlus for Lua... 阅读全文

C++技术中心 2013-04-23 16:53 发表评论

luaplus

C++技术中心 — Tue, 23 Apr 2013 07:00:00 GMT

国内关于Lua的资料实在是太少,为了寻找一个合适的Lua的C++封装,真是如同大海捞针.在看了众多资料后锁定以下几种:LuaBind ToLua++ LuaPlus.在选择上颇有讽刺的味道,LuaBind的版本号还没到1.0,加上网友颇有微词,放弃.ToLua++本来有朋友推荐,但是怎么都找不到下载,官网就是打不开,无赖放弃.就只有LuaPlus了,看到一些人的评价还行,于是决定就用它吧.

LuaPlus的资料就更少了,连怎么配置怎么调试等什么都没有,只有沐枫大哥讲解了语法方面的一篇文章.啊哟,怎么搞呢,难道又只有硬着头皮上了?(某伟人曾说过,但凡杰出的事都是硬着头皮干出来滴)

好了,言归正传,下面讲讲我的经验吧:

如何编译

1. 下载

首先到官方网站下载: http://www.luaplus.org/

下载这个: All source code: http://luaplus.org/LuaPlus51_Build1100.zip (我当前的版本,当然越新越好)

2. 剥离

解开下载包,打开 \LuaPlus51_Build1100\Src\LuaPlus 里面是全部源文件,src下是lua的源文件.这里有个令人疑惑的地方,源文件中带了一些不需要的文件,要剔除去,基本上需要以下这些文件:

1) Lua库文件:

lapi.c

lapi.h

lauxlib.c

lauxlib.h

lbaselib.c

lcode.c

lcode.h

ldblib.c

ldebug.c

ldebug.h

ldo.c

ldo.h

ldump.c

lfunc.c

lfunc.h

lgc.c

lgc.h

linit.c

liolib.c

llex.c

llex.h

llimits.h

lmathlib.c

lmem.c

lmem.h

loadlib.c

lobject.c

lobject.h

lopcodes.c

lopcodes.h

loslib.c

lparser.c

lparser.h

lstate.c

lstate.h

lstring.c

lstring.h

lstrlib.c

ltable.c

ltable.h

ltablib.c

ltm.c

ltm.h

lua.h

luaconf.h

lualib.h

lundump.c

lundump.h

lvm.c

lvm.h

lzio.c

lzio.h

print.c

2) LuaPlus头文件:

auxiliar.h

LuaAutoBlock.h

LuaCall.h

LuaFunction.h

LuaHelper.h

LuaHelper_Object.h

LuaHelper_StackObject.h

LuaLink.h

LuaObject.h

LuaObject.inl

LuaPlus.h

LuaPlusCD.h

LuaPlusFunctions.h

LuaPlusInternal.h

LuaStackObject.h

LuaStackObject.inl

LuaStackTableIterator.h

LuaState.h

LuaState.inl

LuaStateOutFile.h

LuaTableIterator.h

luathread.h

pt.h

srm.h

3) LuaPlus源文件

LuaCall.cpp

LuaObject.cpp

LuaPlus.cpp

LuaPlusAddons.c

LuaPlusFunctions.cpp

LuaPlus_Libs.cpp

LuaStackObject.cpp

LuaStackTableIterator.cpp

LuaState.cpp

LuaStateOutFile.cpp

LuaState_DumpObject.cpp

LuaTableIterator.cpp

lwstrlib.c

3. 建立项目

然后你就可以在VS中建立一个新项目,静态链接库的:

分别把需要的文件加进去,之后编译,应该能通过了.

如何使用

接着讲讲如何在你的其他项目中使用LuaPlus.

1.必要的配置

你的项目可能是这样的:

设置GameClient的依赖项是LuaPlusLib

#include "LuaPlus.h"

using namespace LuaPlus;

记得干这事…

2.创建一个状态

LuaStateOwner state;

今后的操作都围绕这个state

3.执行脚本

int iret = state->DoFile("test.lua");

返回值为0表示成功,否则不成功.

4.C++中获取Lua脚本的变量

假设你的test.lua中有:

health = 200;

通过下列方法就可以在C++中得到这个数值

int mytest = state->GetGlobal("health").GetInteger();

5.C++中调用Lua脚本里的函数

假设你的test.lua中有:

function Add(x, y)

return x+y;

end

在C++中需要先声明这个函数:

LuaFunction Add = state->GetGlobal("Add");

这样你就有了Add()这个函数,然后就可以像平常一样使用它了:

float myret = Add(3.14f,5.25f);

6.Lua脚本中调用C++函数

在读取test.lua之前要先把C++函数注册到Lua的运行时栈里,这样在执行lua脚本的时候,才知道执行哪一个函数:

首先有函数:

int LS_PrintNumber(LuaState* state)

{

LuaStack args(state);

if (args[1].IsNumber()) {

printf("%f\n", args[1].GetNumber());

}

return 0;

}

然后注册这个函数到Lua:

state->GetGlobals().Register("PrintNumber", LS_PrintNumber);

这样就把LS_PrintNumber映射为Lua中可以使用的函数PrintNumber.

Test.lua脚本中添加调用语句:

PrintNumber(30);

当state->DoFile("test.lua");执行的时候,就执行了C++中的这个函数.

总结

本文介绍了LuaPlus的基本配置方法和使用,希望对你有帮助.下一篇将介绍一些高级特性,如怎样在VS中调试LuaPlus的脚本,以及对类的操作等.

如果还有任何疑问可以看看下面这个简单的例子:
/Files/singohgod/LuaPlus_Test.rar

C++技术中心 2013-04-23 15:00 发表评论

lua 调 c++类

C++技术中心 — Mon, 22 Apr 2013 09:51:00 GMT

摘要: 1.其中lua脚本文件内容，t.lua如下： function f(ab) print(ab)end ret ,err= pcall(f, "hello world") print( ret) print(err) print("okkkkkkkkkkk")2.代码如下： Code highlighting pro... 阅读全文

C++技术中心 2013-04-22 17:51 发表评论

c/c++与lua脚本互调

C++技术中心 — Mon, 22 Apr 2013 08:31:00 GMT

1.lua脚本func.lua如下：

-- -------------------------------------

--变量定义
width=1;
height=2;

--lua函数定义，实现加法
function sum(a,b)
return a+b ;
end

--lua函数定义，实现字符串相加
function mystrcat(a,b)
return a..b ;
end

--lua函数定义，通过调用c代码中的csum函数实现加法
function mysum(a,b)
return csum(a,b);
end
-- -------------------------------------

2.c/c++代码如下：

#include "stdafx.h"
#include <stdlib.h>
#include <string.h>
#include <errno.h>

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

#define err_exit(num,fmt,args)  \
    do{printf("[%s:%d]"fmt"\n",__FILE__,__LINE__,##args);exit(num);} while(0)

#define err_return(num,fmt,args)  \
    do{printf("[%s:%d]"fmt"\n",__FILE__,__LINE__,##args);return(num);} while(0)

//lua中调用的c函数定义,实现加法
int csum(lua_State* l)
{
    int a = lua_tointeger(l,1) ;
    int b = lua_tointeger(l,2) ;
    lua_pushinteger(l,a+b) ;
    return 1 ;
}

int main(int argc,char** argv)
{
    lua_State * l = luaL_newstate() ;        //创建lua运行环境

    if ( l == NULL ) err_return(-1,"luaL_newstat() failed",1);

    int ret = 0 ;
    ret = luaL_loadfile(l,"func.lua") ;      //加载lua脚本文件
    if ( ret != 0 ) err_return(-1,"luaL_loadfile failed",1) ;


    ret = lua_pcall(l,0,0,0) ;
    if ( ret != 0 ) err_return(-1,"lua_pcall failed:%s",lua_tostring(l,-1)) ;

    lua_getglobal(l,"width");              //获取lua中定义的变量
    lua_getglobal(l,"height");
    printf("height:%ld width:%ld\n",lua_tointeger(l,-1),lua_tointeger(l,-2)) ;
    lua_pop(l,1) ;                        //恢复lua的栈

    int a = 11 ;
    int b = 12 ;
    lua_getglobal(l,"sum");               //调用lua中的函数sum
    lua_pushinteger(l,a) ;
    lua_pushinteger(l,b) ;
    ret = lua_pcall(l,2,1,0) ;
    if ( ret != 0 ) err_return(-1,"lua_pcall failed:%s",lua_tostring(l,-1)) ;
    printf("sum:%d + %d = %ld\n",a,b,lua_tointeger(l,-1)) ;
    lua_pop(l,1) ;

    const char str1[] = "hello" ;
    const char str2[] = "world" ;
    lua_getglobal(l,"mystrcat");          //调用lua中的函数mystrcat
    lua_pushstring(l,str1) ;
    lua_pushstring(l,str2) ;
    ret = lua_pcall(l,2,1,0) ;
    if ( ret != 0 ) err_return(-1,"lua_pcall failed:%s",lua_tostring(l,-1)) ;
    printf("mystrcat:%s%s = %s\n",str1,str2,lua_tostring(l,-1)) ;
    lua_pop(l,1) ;

    lua_pushcfunction(l,csum) ;         //注册在lua中使用的c函数
    lua_setglobal(l,"csum") ;           //绑定到lua中的名字csum

    lua_getglobal(l,"mysum");           //调用lua中的mysum函数，该函数调用本程序中定义的csum函数实现加法
    lua_pushinteger(l,a) ;
    lua_pushinteger(l,b) ;
    ret = lua_pcall(l,2,1,0) ;
    if ( ret != 0 ) err_return(-1,"lua_pcall failed:%s",lua_tostring(l,-1)) ;
    printf("mysum:%d + %d = %ld\n",a,b,lua_tointeger(l,-1)) ;
    lua_pop(l,1) ;

    lua_close(l) ;                     //释放lua运行环境
    return 0 ;
}

C++技术中心 2013-04-22 16:31 发表评论

lua脚本

C++技术中心 — Mon, 22 Apr 2013 06:33:00 GMT

1. 下载地址www.lua.org
2. 安装
3.新建工程，加入Lua\5.1\lib中的lib库，及路径，并且加入include路径。
4.新建add.lua文件

function add ( x, y )

return x + y

end

#include "stdafx.h"

extern "C" {
#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
}

lua_State* L;

int luaadd ( int x, int y )
{
    int sum;
    /* lua中的函数 */
    lua_getglobal(L, "add");

    /* 压入虚拟栈的第一个值 */
    lua_pushnumber(L, x);

    /* 第二个值 */
    lua_pushnumber(L, y);

    /* 调用传入的两个值，并返回一个结果 */
    lua_call(L, 2, 1);

    /*得到结果，由于返回类型不同这里要显示的强制转换*/
    sum = (int)lua_tointeger(L, -1);

    lua_pop(L, 1);
    return sum;
}

int _tmain(int argc, _TCHAR* argv[])
{

    int sum;

    /* Lua初始化*/
    L = lua_open();

    /*加载lua基本库 */
    luaL_openlibs(L);

    /*加载文件add.lua */
    luaL_dofile(L, "add.lua");

    /* 调用加法的方法 */
    sum = luaadd( 200, 50 );

    /*打印结果 */
    printf( "The sum is %d\n", sum );
    lua_close(L);
    printf( "Press enter to exit" );
    getchar();

    return 0;
}

5.cpp文件如下：

C++技术中心 2013-04-22 14:33 发表评论

内存池的实现(一)

C++技术中心 — Sat, 16 Mar 2013 05:06:00 GMT

引言

C/C++下内存管理是让几乎每一个程序员头疼的问题，分配足够的内存、追踪内存的分配、在不需要的时候释放内存——这个任务相当复杂。而直接使用系统调用malloc/free、new/delete进行内存分配和释放，有以下弊端：

调用malloc/new,系统需要根据“最先匹配”、“最优匹配”或其他算法在内存空闲块表中查找一块空闲内存，调用free/delete,系统可能需要合并空闲内存块，这些会产生额外开销
频繁使用时会产生大量内存碎片，从而降低程序运行效率
容易造成内存泄漏

内存池（memory pool)是代替直接调用malloc/free、new/delete进行内存管理的常用方法，当我们申请内存空间时，首先到我们的内存池中查找合适的内存块，而不是直接向操作系统申请，优势在于：

比malloc/free进行内存申请/释放的方式快
不会产生或很少产生堆碎片
可避免内存泄漏

内存池设计

看到内存池好处这么多，是不是恨不能马上抛弃malloc/free，投奔内存池的怀抱呢？且慢，在我们自己动手实现内存池之前还需要明确以下几个问题：

内存池的空间如何获得？是程序启动时分配一大块空间还是程序运行中按需求分配？
内存池对到来的内存申请，有没有大小的限制？如果有，最小可申请的内存块为多大，最大的呢？
如何合理设计内存块结构，方便我们进行内存的申请、追踪和释放呢？
内存池占用越多空间，相对应其他程序能使用的内存就越少，是否要设定内存池空间的上限？设定为多少合适呢？

带着以上问题，我们来看以下一种内存池设计方案。

内存池实现方案一

从这里下载该内存池实现的源码。

首先给出该方案的整体架构，如下：

图1.内存池架构图

结构中主要包含block、list和pool这三个结构体，block结构包含指向实际内存空间的指针，前向和后向指针让block能够组成双向链表；list结构中free指针指向空闲内存块组成的链表，used指针指向程序使用中的内存块组成的链表，size值为内存块的大小，list之间组成单向链表；pool结构记录list链表的头和尾。

内存跟踪策略

该方案中，在进行内存分配时，将多申请12个字节，即实际申请的内存大小为所需内存大小+12。在多申请的12个字节中，分别存放对应的list指针（4字节）、used指针（4字节）和校验码（4字节）。通过这样设定，我们很容易得到该块内存所在的list和block，校验码起到粗略检查是否出错的作用。该结构图示如下：

图2.内存块申请示意图

图中箭头指示的位置为内存块真正开始的位置。

内存申请和释放策略

申请：根据所申请内存的大小，遍历list链表，查看是否存在相匹配的size；

　　　　存在匹配size：查看free时候为NULL

　　　　　　free为NULL：使用malloc/new申请内存，并将其置于used所指链表的尾部

　　　　　　free不为NULL：将free所指链表的头结点移除，放置于used所指链表的尾部

　　　　不存在匹配size：新建list，使用malloc/new申请内存，并将其置于该list的used所指链表尾部

　　　返回内存空间指针

释放：根据内存跟踪策略，获取list指针和used指针，将其从used指针所指的链表中删除，放置于free指针所指向的链表

对方案一的分析

对照“内存池设计”一节中提出的问题，我们的方案一有以下特点：

程序启动后内存池并没有内存块，到程序真正进行内存申请和释放的时候才接管内存块管理；
该内存池对到来的申请，对申请大小并不做限制，其为每个size值创建链表进行内存管理；
该方案没有提供限定内存池大小的功能

结合分析，可以得出该方案应用场景如下：程序所申请的内存块大小比较固定（比如只申请/释放1024bytes或2048bytes的内存），申请和释放的频率基本保持一致（因申请多而释放少会占用过多内存，最终导致系统崩溃）。

这篇文章讲解了内存管理的基本知识，以一个简单的内存池实现例子作为敲门砖，引领大家认识内存池，下一篇为内存池进阶文章，讲解apache服务器中内存池的实现方法。

C++技术中心 2013-03-16 13:06 发表评论

内存池实现 (思路)

C++技术中心 — Sat, 16 Mar 2013 04:43:00 GMT

话说一直想找一个别人写好的使用，可惜没什么人会拿这小东西发布，只好自写一个。

1.多级链表分配池
我不知道这种设计的具体学名是什么，这部分的内容也许你去看《STL源码分析》的有关章节更合适一些，这里我只能用我粗陋的语言描述一下。
内存池，完全可以从字面上理解为从池子里申请内存，释放的时候还给池子。
最简单的内存池应该是fix_pool吧，即每次分配出来的内存块大小是固定的。这种池子的管理结构是一个链表，链表的每一个节点为固定大小的内存块。分配的时候，直接返回链表的第一个节点，节点不足时，从系统申请大块内存分成多个节点加入链表；释放的时候更简单，将释放的内存加入链表头。
假设fix_pool的fix size = 128，那么内存池可以为128byte以下的任意大小的请求进行分配，但是这样做相当浪费呢，于是unfix_pool就在此基础上出现了。
由多个分配大小不同的fix_pool所组成的内存池就叫做多级链表分配池，我是这么定义的。
常规上会定义8,16,24,32,...,112,120,128这些分配大小，共16级。分配或者释放的时候，判断请求的大小在哪一级别上，用该级别的fix_pool链表进行分配或者释放。

2.泄漏检测
当所有的分配都经过你的手的时候，泄漏检测什么的再简单不过了。
找个地方把分配的东西记录下来，释放的时候把记录去掉。程序退出的时候还存在的分配记录就是泄漏了。
我个人选用的方法是给每一个分配请求多分配一些内存，用来记录分配的信息，并将这部分信息用双向链表串起来。释放的时候对释放的指针做一下指针偏移就可以找到信息记录并移出双向链表。
这个方法的开销是常数级的，不过无法处理重复删除的问题。

3.operater new
要把你的内存池应用到每一个角落，需要定义operator new和operator delete。

void* operator new(size_t) throw(std::bad_alloc);
void operator delete(void* p);

但是这还不够，谁也不想看到一堆泄漏信息而找不到泄漏的位置，因此还需要定义带附加参数的operator。
对于placement new而言，operator new[]和operator delete[]是必须的，无法省略。

void* operator new(size_t, const char* file, int line, const char* function);
void* operator new[](size_t, const char*, int, const char*);
void operator delete(void* p);
void operator delete[](void* p);

为了能用上新的operator，需要在头文件中重新定义new，并包含进每一个cpp文件。

//op_new.h
#define DEBUG_NEW new(__FILE__, __LINE__, __FUNCTION__)
#define new DEBUG_new

不过重定义new会和自行使用placement new的地方冲突，如stl容器库，这时候要undef new后才能编译冲突组件。

#undef new
#include <vector>
#include "op_new.h"

4.线程安全
我没听说过new/delete,malloc/free是线程不安全的，所以在内存池的allocate/deallocate接口处直接加了锁。
想降低开销的同学可以使用spin lock，而不是mutex。

C++技术中心 2013-03-16 12:43 发表评论

Memcache存储大数据的问题

C++技术中心 — Fri, 19 Oct 2012 09:20:00 GMT

Memcached存储单个item最大数据是在1MB内，如果数据超过1M,存取set和get是都是返回false，而且引起性能的问题。

我们之前对排行榜的数据进行缓存，由于排行榜在我们所有sql select查询里面占了30%，而且我们排行榜每小时更新一次，所以必须对数据做缓存。为了清除缓存方便，把所有的用户的数据放在同一key中，由于memcached:set的时候没有压缩数据。在测试服测试的时候，没发现问题，当上线的时候，结果发现，在线人数刚刚490人的时候，服务器load average飘到7.9。然后我们去掉缓存，一下子就下降到0.59。

所以Memcahce不适合缓存大数据，超过1MB的数据，可以考虑在客户端压缩或拆分到多个key中。大的数据在进行load和uppack到内存的时候需要花很长时间，从而降低服务器的性能。

Memcached支持最大的存储对象为1M。这个值由其内存分配机制决定的。

memcached默认情况下采用了名为Slab Allocator的机制分配、管理内存。在该机制出现以前，内存的分配是通过对所有记录简单地进行malloc和free来进行的。但是，这种方式会导致内存碎片，加重操作系统内存管理器的负担，最坏的情况下，会导致操作系统比memcached进程本身还慢。Slab Allocator就是为解决该问题而诞生的。Slab Allocator的基本原理是按照预先规定的大小，将分配的内存分割成特定长度的块，以完全解决内存碎片问题.

今天（2012-03-16）我们重新测试了memcached ::set的数据大小。可能是我们用php的memcached扩展是最新版，set数据的时候是默认压缩的。set 数据：

[plain] view plain copy print ?

$ac = new memcahed();
$data = str_repeat('a', 1024* 1024); //1M的数据
$r = $ac->set('key', $data, 9999);
//或者
$data = str_repeat('a', 1024* 1024*100);//100M的数据
$r = $ac->set('key', $data, 9999);

$ac = new memcahed();
$data = str_repeat('a', 1024* 1024); //1M的数据
$r  =  $ac->set('key', $data, 9999);
//或者
$data = str_repeat('a', 1024* 1024*100);//100M的数据
$r  =  $ac->set('key', $data, 9999);

不论是1M的数据还是100M的数据，都能set成功。后来我发现，memcachedset数据的时候是默认压缩的。由于这个这个是重复的字符串，压缩率高达1000倍。因此100M的数据压缩后实际也就100k而已。

当我设置：

[plain] view plain copy print ?

$ac->setOption(memcahed::OPT_COMPRESSION,0); //不压缩存储数据。
$data = str_repeat('a', 1024* 1024); //1M数据
$r = $ac->set('key', $data, 9999);//1M的数据set不成功。

$ac->setOption(memcahed::OPT_COMPRESSION,0); //不压缩存储数据。
$data = str_repeat('a', 1024* 1024); //1M数据
$r  =  $ac->set('key', $data, 9999);//1M的数据set不成功。

也就是说memcached server不能存储超过1M的数据，但是经过客户端压缩数据后，只要小于1M的数据都能存储成功。

memcached相关知识：

1、memcached的基本设置
1）启动Memcache的服务器端
# /usr/local/bin/memcached -d -m 10 -u root -l 192.168.0.200 -p 12000 -c 256 -P /tmp/memcached.pid

-d选项是启动一个守护进程，
-m是分配给Memcache使用的内存数量，单位是MB，我这里是10MB，
-u是运行Memcache的用户，我这里是root，
-l是监听的服务器IP地址，如果有多个地址的话，我这里指定了服务器的IP地址192.168.0.200，
-p是设置Memcache监听的端口，我这里设置了12000，最好是1024以上的端口，
-c选项是最大运行的并发连接数，默认是1024，我这里设置了256，按照你服务器的负载量来设定，
-P是设置保存Memcache的pid文件，我这里是保存在 /tmp/memcached.pid，

2）如果要结束Memcache进程，执行：

# kill `cat /tmp/memcached.pid`

哈希算法将任意长度的二进制值映射为固定长度的较小二进制值，这个小的二进制值称为哈希值。哈希值是一段数据唯一且极其紧凑的数值表示形式。如果散列一段明文而且哪怕只更改该

段落的一个字母，随后的哈希都将产生不同的值。要找到散列为同一个值的两个不同的输入，在计算上是不可能的。

2、适用memcached的业务场景？

1）如果网站包含了访问量很大的动态网页，因而数据库的负载将会很高。由于大部分数据库请求都是读操作，那么memcached可以显著地减小数据库负载。

2）如果数据库服务器的负载比较低但CPU使用率很高，这时可以缓存计算好的结果（ computed objects ）和渲染后的网页模板（enderred templates）。

3）利用memcached可以缓存session数据、临时数据以减少对他们的数据库写操作。

4）缓存一些很小但是被频繁访问的文件。

5）缓存Web 'services'（非IBM宣扬的Web Services，译者注）或RSS feeds的结果.。

3、不适用memcached的业务场景？

1）缓存对象的大小大于1MB

Memcached本身就不是为了处理庞大的多媒体（large media）和巨大的二进制块（streaming huge blobs）而设计的。

2）key的长度大于250字符

3）虚拟主机不让运行memcached服务

如果应用本身托管在低端的虚拟私有服务器上，像vmware, xen这类虚拟化技术并不适合运行memcached。Memcached需要接管和控制大块的内存，如果memcached管理的内存被OS或 hypervisor交换出去，memcached的性能将大打折扣。

4）应用运行在不安全的环境中

Memcached为提供任何安全策略，仅仅通过telnet就可以访问到memcached。如果应用运行在共享的系统上，需要着重考虑安全问题。

5）业务本身需要的是持久化数据或者说需要的应该是database

4、不能能够遍历memcached中所有的item

这个操作的速度相对缓慢且阻塞其他的操作（这里的缓慢时相比memcached其他的命令）。memcached所有非调试（non-debug）命令，例如add, set, get, fulsh等无论

memcached中存储了多少数据，它们的执行都只消耗常量时间。任何遍历所有item的命令执行所消耗的时间，将随着memcached中数据量的增加而增加。当其他命令因为等待（遍历所有item的命令执行完毕）而不能得到执行，因而阻塞将发生。

5、 memcached能接受的key的最大长度是250个字符

memcached能接受的key的最大长度是250个字符。需要注意的是，250是memcached服务器端内部的限制。如果使用的Memcached客户端支持"key的前缀"或类似特性，那么key（前缀+原始key）的最大长度是可以超过250个字符的。推荐使用较短的key，这样可以节省内存和带宽。

6、单个item的大小被限制在1M byte之内

因为内存分配器的算法就是这样的。

详细的回答：

1）Memcached的内存存储引擎，使用slabs来管理内存。内存被分成大小不等的slabs chunks（先分成大小相等的slabs，然后每个slab被分成大小相等chunks，不同slab的chunk大小是不相等的）。chunk的大小依次从一个最小数开始，按某个因子增长，直到达到最大的可能值。如果最小值为400B，最大值是1MB，因子是1.20，各个slab的chunk的大小依次是：

slab1 - 400B；slab2 - 480B；slab3 - 576B ...slab中chunk越大，它和前面的slab之间的间隙就越大。因此，最大值越大，内存利用率越低。Memcached必须为每个slab预先分配内存，因此如果设置了较小的因子和较大的最大值，会需要为Memcached提供更多的内存。

2）不要尝试向memcached中存取很大的数据，例如把巨大的网页放到mencached中。因为将大数据load和unpack到内存中需要花费很长的时间，从而导致系统的性能反而不好。如果确实需要存储大于1MB的数据，可以修改slabs.c：POWER_BLOCK的值，然后重新编译memcached；或者使用低效的malloc/free。另外，可以使用数据库、MogileFS等方案代替Memcached系统。

7、 memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？

实际上，这是一个编译时选项。默认会使用内部的slab分配器，而且确实应该使用内建的slab分配器。最早的时候，memcached只使用malloc/free来管理内存。然而，这种方式不能与OS的内存管理以前很好地工作。反复地malloc/free造成了内存碎片，OS最终花费大量的时间去查找连续的内存块来满足malloc的请求，而不是运行memcached进程。slab分配器就是为了解决这个问题而生的。内存被分配并划分成chunks，一直被重复使用。因为内存被划分成大小不等的slabs，如果item的大小与被选择存放它的slab不是很合适的话，就会浪费一些内存。

8、memcached对item的过期时间有什么限制？

item对象的过期时间最长可以达到30天。memcached把传入的过期时间（时间段）解释成时间点后，一旦到了这个时间点，memcached就把item置为失效状态，这是一个简单但obscure的机制。

9、什么是二进制协议，是否需要关注？

二进制协议尝试为端提供一个更有效的、可靠的协议，减少客户端/服务器端因处理协议而产生的CPU时间。根据Facebook的测试，解析ASCII协议是memcached中消耗CPU时间最多的

环节。

10、 memcached的内存分配器是如何工作的？为什么不适用malloc/free！？为何要使用slabs？

11、memcached是原子的吗？

所有的被发送到memcached的单个命令是完全原子的。如果您针对同一份数据同时发送了一个set命令和一个get命令，它们不会影响对方。它们将被串行化、先后执行。即使在多线程模式，所有的命令都是原子的。然是，命令序列不是原子的。如果首先通过get命令获取了一个item，修改了它，然后再把它set回memcached，系统不保证这个item没有被其他进程（process，未必是操作系统中的进程）操作过。memcached 1.2.5以及更高版本，提供了gets和cas命令，它们可以解决上面的问题。如果使用gets命令查询某个key的item，memcached会返回该item当前值的唯一标识。如果客户端程序覆写了这个item并想把它写回到memcached中，可以通过cas命令把那个唯一标识一起发送给memcached。如果该item存放在memcached中的唯一标识与您提供的一致，写操作将会成功。如果另一个进程在这期间也修改了这个item，那么该item存放在memcached中的唯一标识将会改变，写操作就会

失败。

Windows下的Memcache安装：
1. 下载memcache的windows稳定版，解压放某个盘下面，比如在c:/memcached
2. 在终端（也即cmd命令界面）下输入 ‘c:/memcached/memcached.exe -d install’ 安装
3. 再输入： ‘c:/memcached/memcached.exe -d start’ 启动。NOTE: 以后memcached将作为windows的一个服务每次开机时自动启动。这样服务器端已经安装完毕了。

/usr/local/memcached/bin/memcached -u root -d -m 3072 -l 192.168.121.130 -p 50008 -U 0 -P /var/run/memcache.pid

C++技术中心 2012-10-19 17:20 发表评论

typeid用法

C++技术中心 — Sat, 15 Sep 2012 02:13:00 GMT

#include <iostream>
#include <typeinfo>
using namespace std;
class Test
{
public:
virtual ~Test()
{
}
virtual void Out()
{
  cout<<typeid(*this).name()<<endl;
}
Test()
{
  cout<<typeid(*this).name()<<endl;
}
};
class FromTest : public Test
{
public:
FromTest(){}
};
void main()
{
// void * v=new Test;
//    Test * t=static_cast(v);
//// Test * t=(Test *)(v);
// cout<// t->Out();
// int i;
// cout<
FromTest ft;

Test * t;//=new FromTest;
Test l;
l.Out();
t=&ft;
cout<<typeid(*t).name()<<endl;
}

C++技术中心 2012-09-15 10:13 发表评论

字符串格式化防止数组越界

C++技术中心 — Thu, 08 Mar 2012 01:50:00 GMT

    char buffers[10];

    //_snprintf_s(buffers,sizeof(buffers),"%s","lsdafjasdlfjasdl;fjasdl;fjasd;fjasd;fjasd;fasd;fsd");
    _snprintf(buffers,sizeof(buffers),"%s","lseeeeeeeeeeeeeeeeeeeed");

buffers[9] = 0;

printf("%s",buffers);
fflush(stdin);

C++技术中心 2012-03-08 09:50 发表评论

红黑树及生成超过32768随机数

C++技术中心 — Sun, 11 Dec 2011 09:44:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->/*----------------------------------------------------------- RB-Tree的插入和删除操作的实现算法&n... 阅读全文

C++技术中心 2011-12-11 17:44 发表评论

关于模板中的嵌套依赖类型名与typename

C++技术中心 — Fri, 28 Oct 2011 06:39:00 GMT

typename一共就两种用法

①修饰模板参数,说明它是一个类型.此时可以用class关键字来代替.

②修饰嵌套依赖类型名

关于第②点要说明如下:

1. 依赖类型名: 一个模板中的依赖于一个模板参数的名字.

2. 嵌套依赖类型名: 嵌套在一个类内部的一个依赖类型名

比如:

std::list

首先,它是一个依赖于模板参数的类型,所以它是一个依赖类型名

其次,它也是一个嵌套在std内部的类型,所以它是嵌套依赖类型名,需要用typename来修饰.如下:

typename std::list m_lstT;

记住:

在涉及到一个模板中的嵌套依赖类型名的任何时候,都必须把typename放在紧挨着它的前面

C++技术中心 2011-10-28 14:39 发表评论

判断两日期是否在同一周内

C++技术中心 — Thu, 23 Jun 2011 10:49:00 GMT

一.原由
最近需要编写判断两个日期是否是属于同一周的判断。思路如下：
将每个日期的星期几都归到周一，比如2011-6-23是周四。那将日期减去3天。为2011-6-21正好为周一
。于是将两个日期都按上述方式调整。得到的日期，看是否相等。如果相等，说明两日期是在同一周。

二。具体代码如下：

int GetMonday(int Date)
{
    struct tm t;
    time_t t_of_day;
    t.tm_year=Date/10000-1900;
    t.tm_mon=Date/100%100-1;
    t.tm_mday=Date%100;
    t.tm_hour=0;
    t.tm_min=0;
    t.tm_sec=0;
    t.tm_isdst=0;
    t_of_day=mktime(&t);

    struct tm *pTmp =localtime(&t_of_day);

    int day;
    int week = pTmp->tm_wday;
    if(week==0)
        week = 7;

    day = week - 1;
    t_of_day -= day*24*3600;

    return t_of_day;
}

int _tmain(int argc, _TCHAR* argv[])
{
    int aa = GetMonday(20110109);
    int bb = GetMonday(20110110);

    if(aa == bb)
    {
        printf("为同一周内!\n");
        return 0;
    }

    printf("不为同一周内!\n")


    return 0;
}

C++技术中心 2011-06-23 18:49 发表评论

C++ 虚析构函数的问题

C++技术中心 — Fri, 11 Mar 2011 07:10:00 GMT

一.虚析构函数说明
一般来说,如果有被子类继承的类,尽可能的加上关键字virtual,特别是以下情况,可能没有调用子类的析
构造成内存泄露.

二.代码示例:

#include <iostream>
#include <conio.h>
using namespace std;

class CBase
{
public:
    //注意有加virtual与不加virtual运行情况
    virtual ~CBase()
    {
        cout<<"CBase destructor!"<<endl;
    }
};

class CChild:public CBase
{
public:
    ~CChild()
    {
        cout<<"CChild destructor!"<<endl;
    }
};

int main(int argc,char *argv[])
{
    /*
    以下打印结果是
    CChild destructor!
    CBase destructor!
    */
    CChild  *pchild = new CChild();
    delete pchild;

    /*
    1.以下代码有加virtual运行结果是:
    CChild destructor!
    CBase destructor!

    2.去掉virtual运行结果如下:
    CBase destructor!
    可以看到,没有调用CChild的析构函数
    */
    CBase *pBase = new CChild();
    delete pBase;

    _getch();
    return 0;
}

C++技术中心 2011-03-11 15:10 发表评论

初始化成员列表以及四种强制类型转换使用

C++技术中心 — Tue, 08 Mar 2011 06:54:00 GMT

#include "stdafx.h"
#include <conio.h>
#include <iostream>
#include <string>
using namespace std;
using namespace std;

class CParent
{
public:
    CParent(){}

    //以下在构造函数是初始化成员列表,多个用逗号隔开
    CParent(string strName,int age):strName(strName),m_age(age){}
    virtual string GetName(){return strName;}
private:
    string strName;
    int m_age;
};

class CChild:public CParent
{
public:
    //初始化成员列表父类与本类的成员
    //加入explicit关键字,防止隐式类型转换
    explicit CChild(string strName):CParent("Parent:"+strName,34),strName("Child:"+strName){}
    string GetName(){return strName;}
private:
    string strName;
};

int _tmain(int argc, _TCHAR* argv[])
{
    int pause;

    //调用父类构造
    CParent parent("parent",56);
    cout<<parent.GetName()<<endl;

    //调用子类构造
    CChild child("sky");
    cout<<child.GetName()<<endl;

    //子类构造有加explicit,不可以稳式转换
    //CChild child1 = "explicitTest";
    //cout<
    //1.static_cast类型转换
    //a.指针转换
    CParent *pParent=NULL;
    pParent = static_cast<CParent*>(&child) ;
    cout<<pParent->GetName()<<endl;//调用的是CChild类的GetName

    //b.对象间转换
    CParent tmpParent;
    //tmpParent = (CParent)child;
    tmpParent = static_cast<CParent>(child) ;
    cout<<tmpParent.GetName()<<endl;//调用的是父类GetName,因为tmpParent是Cparent对象
                                    //虚表不起作用

    //2.dynamic_cast类型转换
    CChild *pChild1;
    CChild *pChild2;
    pChild1 = dynamic_cast<CChild*>(&parent);//将返回空指针
    pChild2 = static_cast<CChild*>(&parent); //返回的是parent地址.但调用子类的方法,将不安全
    /*dynamic_cast支持交叉转换
    如果B继承A,C也继承A.
    那么将B用static_cast转成C是编译错误
    将B用dynamic_cast转成C返回NULL指针
    */

    //3.const_cast
    const CParent *constParent=NULL;
    CParent *pParent1 = const_cast<CParent*>(constParent);

    //4.reinterpret_cast
    //最底层的重新解释
    //reinterpret_cast原原本本的位复制,而static_cast有内部解析转换
    int n=9;
    double d1=reinterpret_cast<double & > (n);
    cout<<d1<<endl;

    double d2 = static_cast<double>(n);
    cout<<d2<<endl;

    _getch();
    return 0;
}

C++技术中心 2011-03-08 14:54 发表评论

友元friend在运算符重载中应用

C++技术中心 — Fri, 04 Mar 2011 07:51:00 GMT

#include <conio.h>
#include <string>
#include <iostream>

using namespace std;

class CProduct
{
public:
    CProduct(int high,int weight, string productName);
private:
    friend ostream& operator<<(ostream& os,CProduct &product);
private:
    int m_high;        //高
    int m_weight;      //重量
    string m_productName; //产品名称
};

ostream& operator<<(ostream& os,CProduct &product)
{
     os<<"Product Name:"<<product.m_productName<<" weight:"<<product.m_weight<<" high:"<<product.m_high<<endl;

     return os;
}

inline CProduct::CProduct(int high,int weight, string productName)
{
     this->m_high = high;
     this->m_weight = weight;
     this->m_productName = productName;
}

int main(int argc,char *argv[])
{
    CProduct product(175,30,"pig");;
    cout<<product;

    getch();
    return 0;
}

C++技术中心 2011-03-04 15:51 发表评论