数学建模社区-数学中国

标题: 混沌 In C++ (转自CSDN) [打印本页]

作者: xShandow 时间: 2004-6-30 10:28
标题: 混沌 In C++ (转自CSDN)
<

>混沌 In C++ 一::是类型？还是函数调用？
难度: * * *
文前提醒：看这篇文章时须家长陪同并引导，以免走火入魔
<

>
先看看下面的代码？ 
<

>struct A
<

>{
<

> A(){}
<

>};

<

>template<typename T>
<

>void func(T() )
<

>{}

<

>int main()
<

>{
<

> A a( A() ); <a>file://(</A>1), OK
<

> func( A() ); <a>file://(</A>2), Wrong
<

> a = 5; <a>file://(</A>3), Wrong
<

>}

<

>(1)、 A a( A() ); 是什么意思？
<

>在这里并不是用A()创建一个对象，然后实例化对象a。这里真正的语义是a是一个参数为返回A对象的无参函数指针的函数，所以它的真面目应
<

>该是A a( A (*)() ) 。而这句仅仅起到声明函数的作用。重点就在于A()并不是创建对象，而是一个无参的、返回为A的无名函数
<

>为什么说A() 是一个无名的函数呢？来类比一下
<

>一个普通函数应该这样写 A fun()
<

>现在它是无名的，那么把fun去掉就成了A()

<

>(2)、 func( A() ); 为什么会出错呢？
<

>这里虽然函数模板func的参数同样也是一个无参的、返回为T的函数指针，那为什么会出错呢？其实在这里A()就不是一个无名函数了，而是创
<

>建一个临时对象。那么这个函数即成了 void func( A )，而原本的类型是void func( T (*)() )，很明显参数类型不匹配。

<

>(3)、 a = 5; 现在应该没有任何疑问了
<

>把int 传递给 A (*)( A (*)() )，地球人都知道是错的。

<

>千万别走火入魔！
<

>是什么导致了(1)和(2)中的A()表现出不同的语义呢？
<

>答：注意(1)是声明，当A()这个具有二意性东西出现在声明或定义中，那么它都被看作是“类型”而不是函数调用。所以这样一来，(2)明显
<

>不是定义，所以A()就被解析成调用。 

更多
struct A
{
 A(int ){}
};

A a(A(1)); 在这里A(1) 就不可能是“类型”了，因为其中有个1，由于1不是“类型”，所以A(1)就成了函数调用。
//////////////////////////////////////////////////////////////////////////////////////////
混沌 IN C++ 二::动态资源管理陷阱
难度:* *
先阅读下面的代码然后来解答下面的那个问题
struct A
{};
int main()
{
 A *p = new A;
 p->~A();
 free(p);
}

问题：new/delete 和 malloc/free 有哪些区别？
答：new/delete 会在分配的内存上调用对象的构造函数和析构函数来初始化和销毁对象，而 malloc/free 却不能。更重要的是new/delete 和 
malloc/free 不能混用。
new 是在自由存储区中分配内存，delete 是负责释放自由存储区中的内存
malloc 是在堆中分配内存，free 则负责释放。
自由存储区和堆的访问方式是不同的，或者说是与平台相关的，如果混用那么必将导致程序崩溃。在某些编译器上也许不会出现问题，但永远
相信这是错误的、不可移植的。

现在，上面那段代码有问题吗？
////////////////////////////////////////////////////////////////////////////////////////////////////
混沌 IN C++ 三::模板参数的奥秘
难度:* * * * *
先来一道思考题
template<typename T, T* p>
struct A
{};
假若有个int类型的对象i，那么对于下面这段代码
A<int, &i> obj;
这个是合法的吗？
答： A<int, &i> obj; 可能合法或可能不合法。
什么东西可以当作模板的参数呢？部分的内建类型和用户类型，和部分非类型的东西也可以当作模板参数。
非类型模板参数的一个要求是，编译器能在编译期就能把参数确定下来。换言之，就是非类型的模板参数必须是个编译期常量。
判断这句是否合法得看&i返回的是不是一个编译期常量。当i是全局或静态对象，那么这个语句就是正确的，因为全局和静态对象的内存分配发
生在编译期，所以这样一来i的地址(&i的值)就是可以被确定的。
现在把这个程序补全成合法的
int i;
int main()
{
 A<int, &i> obj;
}
如果这个模板的第二个参数是引用，那么也是同理。不过值得注意的是，这些非类型、非引用模板参数都不是左值！
最后，可以当作非类型参数的东西有整数、enum类型、指针、引用。

其中局部的用户自定义类型(Local Class)不能作为模板参数。这是因为局部类没有外部连接。举个例子
template<typename T>
class TEST{};
void fun1()
{
 struct X{};
 TEST<X> a;
}
void fun2()
{
 struct X{};
 TEST<X> a;
}
上面的TEST<X> a;是同一个东西吗？ 
由于没有外部连接，它们就是同一个东西，而程序员的本意是两个局部类X是两个不同的类定义，也认为TEST<A>是两个不同的模板实例。
对于局部类，可以说它是健全的C++类型系统的一个畸形儿。没有外部连接导致它不能拥有static data members，不能拥有template member 
functions等等。
////////////////////////////////////////////////////////////////////////////////////////////////
混沌 IN C++ 四::Template Metaprograms
难度:* * * *

文前说明：文中涉及到的观点并不是要求你去遵循它，而本文只相当于一篇“科普文章”。其中的关于template的语法在这里就不过多介绍了
。例如，下文中提到的条件，都是要意识到是编译期常量。
C++ template 为我们提供了编译期计算的功能。编译器在处理template时，实际上相当于一个解释器的作用。充分利用template可以提高代码
的运行速度，可以降低代码维护的复杂度，还可以为代码提供更具扩展性的能力。下面就尝试一下这样的编程方式。

一、 C++ template替代if/if-else语句
if(条件) 
语句1;
else 
语句2;
 
在C++ template中，我们可以这样写
template<bool cond>
struct my_if{};

template<>
struct my_if<true>{
static void go()
{ 语句1; }
};

template<>
struct my_if<false>{
static void go()
{ 语句2; }
};

例如，我们判断两个整数
my_if<(1<5)>::go(); 
也许你会觉得这个if/if-else的template有点大提小做的感觉，呵呵，继续往下看

二、 将C++ template版的if/if-else扩展成能应付switch的代码
如果你是一个面向对象编程的高手，你肯定不会在你的代码中安置switch这样的代码，你肯定会用通过抽象、继承、多态和接口来完成这个任
务。不过现在要换一个思维，用C++ template来实现。其实这里的代码和上面的if/if-else相差无几，但是在用于switch时，也同样能出色地
体现出OC原则。
int i;
switch(i)
{
 case 值1;
 语句1;
 break;
 case 值2;
 语句2;
 break;
 default:
 语句3;
}

下面是C++ template版本
template<int I>
struct my_switch{
 static void go(){
 语句3;
}
};

template<>
struct my_switch<值1>{
static void go()
{ 语句1; }
};

template<>
struct my_switch <值2>{
static void go()
{ 语句2; }
};

调用就是my_switch<值>::go();
你也许仍然找不出C++ template版本的switch好处，因为它要写更多的代码。不过你现在静下来认真的想一想，你会发现当你为switch插入新
的值判断时，你要返回到switch处，而且还要修改内部的代码。而用C++ template却不需要你去关心my_switch到底在哪里定义的。要添加新的
值判断时，只需要你自己在一个合适的地方添加值判断的代码。

三、 基于C++ template的数值运算
计算一个常数N的阶乘
template<int N>
struct factorial{
 static const int value = N * factorial<N-1>::value;
};

template<>
struct factorial<1>{
 static const int value = 1;
};
当这个类模板实例化factorial<N>，就会接着实例化factorial<N-1>，直到实例化fatorial<1>为止。而你只需要实例化自己想要计算的N就行
了，后面的一切全由编译器包办。例如我们要输出10的阶乘答案
std::cout<<factorial<10><<std::endl;

四、 借助上面数值计算的方法以产生更实用的代码
是否考虑过得到指针的原型，比如通过int*，得到int。我们可以写出下面的代码
template<typename T>
struct primitive_type{
 typedef T value_type;
};

template<typename T>
struct primitive_type<T*>{
 typedef T value_type;
};

typedef int* pint;
primitive_type<pint>::value_type obj=5;
std::cout<<obj<<std::endl;

现在可以明确obj不是int*，而是int类型。但是有个缺陷就是但T是int**时却的不到int，而是得到的int*，这并不是我们想要的答案。现在只
需要其实稍微对primitive_type的偏特化版本作下简单的修改，就可以满足要求
template<typename T>
struct primitive_type<T*>{
 typedef typename primitive_type<T>::value_type value_type;
};

typedef int**** pint;
primitive_type<pint>::value_type obj=5; 这个obj可以确认他是int，而不是int***

欢迎光临数学建模社区-数学中国 (http://www.madio.net/)