文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

继续贪心，POJ上找不到，Vijos上倒是有，不过它现在挂了...

阅读全文...

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

今天研究了一下sizeof，之前一直以为它是函数，因为它有参数也有返回值，不过今天发现sizeof实际上是一个...恩，算是运算符吧，或者说他是一个宏，因为他是在编译时确定值的，而表达式中的任何运算和函数调用都不会发生。不过有一个例外是C99支持的不定长数组，这时会计算不定长数组的长度。

废话少说，先看一段代码，今天测试sizeof的时候发现的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#define SIZE 10
 
using namespace std;
 
int size1(int array[SIZE])
{
	return sizeof(array);
}
 
int size2(int (&array)[SIZE])
{
	return sizeof(array);
}
 
int main()
{
	int array[SIZE];
	cout << sizeof(array) << endl;
	cout << size1(array) << endl;
	cout << size2(array) << endl;
	return 0;
}

代码运行的结果是

40
4
40

第一个结果不解释了，就是数组所占的内存空间。

第三个结果也不解释了，引用就表示数组本身，也是数组所占的内存空间。

关键来看一下第二个结果。在C语言中，数组名是被当成指针来处理的，具体来讲数组名就是指向数组首元素地址的指针，因此，当数组名被当成参数传递到函数中时，数组名会自动转变成指针，所以此时sizeof的结果就是指针所占的内存大小，在32位系统下就是4

另一个概念，C语言的编译器遇到数组元素array[i]，就会替换成*(array+i)的形式。

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

无意间发现的一个问题，纠结了半天，Google也没找到准确的答案，我想还是得学了汇编和编译原理才能理解吧...

先看两个代码，第一个是C程序，第二个是C++程序，除了头文件不同以外其他的都一样。

//demo.c
#include <stdio.h>
 
int foo();
 
int main()
{
	int a;
	foo(a);
	return 0;	
}
 
int foo(int a)
{
}

//demo.cpp
#include <iostream>
 
int foo();
 
int main()
{
	int a;
	foo(a);
	return 0;
}
 
int foo(int a)
{
}

结果是C程序编译成功，C++程序编译失败，提示函数声明和函数定义参数列表不符...这很正常，关键是C程序怎么可能编译通过...我知道C可以写可变参数列表，问题是我没加那个"..."啊，囧，看来是编译器的问题了，因为代码一样...

C传参数也应该是调用栈吧，难道C编译器根本不管函数声明里的参数列表？囧，那岂不是说C的函数声明根本就没用...

算了，保留问题，以后解决...

//2010.4.14补充

那天Felix说他在GCC下无法编译，一直没时间求证，刚才跑到CentOS上编译了一下，发现我的可以编译成功，囧了...

Felix，出来给我解释一下...

//2010.4.21补充

恩，又查了一些国外的资料，大致了解了上面那个问题的成因，同时也知道了f()和f(void)的区别，之前一直以为他们是一样的...

In C, the declaration int f(void) means a function returning int that takes no parameters.
在C语言中，f(void)表明函数返回整型并且没有任何参数。

The declaration int f() means a function returning int that takes any number of parameters.(takes an unknown number of parameters of unknown types, giving it the wrong number results in undefined behavior. )
而f()表明函数返回整型并且可以使用任意个数的参数，但是他的行为是不确定的。

由此可以看出，在C语言中是推荐使用f(void)这种形式的，因为它明确指明了函数没有参数，f()由于可以使用任意个数的参数，当然也包括没有参数。

而在C++中，我想是不推荐使用f(void)这种形式的，因为f()已经明确表明没有任何参数了。

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

C语言:

char a = 'a';

sizeof(char) = 1

sizeof(a) = 1

sizeof('a') = 4

C++语言:

char a = 'a';

sizeof(char) = 1

sizeof(a) = 1

sizeof('a') = 1

字符型变量是1字节这个没错，奇怪就奇怪在C语言认为'a'是4字节，而C++语言认为'a'是1字节，纠结了...

网上查了一下，原来是规则，原因如下:

C99标准的规定，'a'叫做整型字符常量(integer character constant)，被看成是int型，所以在32位机器上占4字节。

ISO C++标准规定，'a'叫做字符字面量(character literal)，被看成是char型，所以占1字节。

总之，C语言认为'a'是一个数，而C++语言认为'a'是一个字符。我还是喜欢C++的理解...

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

这个问题不是疑问了，查了一下国外网站，总结一下。假设Person是一个类，复制构造函数的调用会在以下几种情况下发生:

1、对象在创建时使用其他的对象初始化

Person p(q); //此时复制构造函数被用来创建实例p

Person p = q; //此时复制构造函数被用来在定义实例p时初始化p

2、对象作为函数的参数进行值传递时

f(p); //此时p作为函数的参数进行值传递，p入栈时会调用复制构造函数创建一个局部对象，与函数内的局部变量具有相同的作用域

需要注意的是，赋值并不会调用复制构造函数，赋值只是赋值运算符(重载)在起作用

p = q; //此时没有复制构造函数的调用！

简单来记的话就是，如果对象在声明的同时将另一个已存在的对象赋给它，就会调用复制构造函数；如果对象已经存在，然后将另一个已存在的对象赋给它，调用的就是赋值运算符(重载)

默认的复制构造函数和赋值运算符进行的都是"shallow copy"，只是简单地复制字段，因此如果对象中含有动态分配的内存，就需要我们自己重写复制构造函数或者重载赋值运算符来实现"deep copy"，确保数据的完整性和安全性。

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

Nope.

看下面一段代码，我们希望能使用构造函数Foo::Foo(char x)去调用本类的另一个构造函数Foo::Foo(char x, int y)，这样可以偷懒(=_=)，但是很可惜，在C++中我们不可以这么做...继续往下看

class Foo()
{
public:
Foo(char x);
Foo(char x, int y);
...
}
 
Foo::Foo(char x)
{
...
Foo(x, 0);  // this line does NOT help initialize the this object!!
...
}

在执行构造函数时，Foo(x, 0)并不会调用"this"对象的Foo::Foo(char x, int y)，而是会用Foo::Foo(char x, int y)来创建一个新的临时实例对象，然后当这条语句执行完后，这个新的临时对象马上就会被销毁。这样一来，"this"对象就没有被初始化，以后使用"this"对象就有可能产生一些问题...时刻记得构造函数是用来初始化对象的，如果想偷懒，可以在构造函数里调用一个自己写的私有init()初始化函数...

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

假设List是一个C++类的名字，问: List x 和 List x() 有区别么？

A big difference!

函数f()声明了一个名为x的List类的实例

void f()
{
List x;     // Local object named x (of class List)
...
}

而函数g()声明的是一个名为x()的函数，它的返回值是一个List

void g()
{
List x();   // Function named x (that returns a List)
...
}

注意，这个和构造函数不一样(new List & new List())...

文章作者：Slyar 文章来源：Slyar Home (www.slyar.com) 转载请注明，谢谢合作。

这学期开了C++课，讲到构造函数和析构函数的时候我产生了一个疑问，老师说要学了操作系统才能明白，暂时先记录一下，以后回来解决。

很早以前就知道main()是程序执行的入口，一直理解的都是操作系统从main()开始的地方执行程序，但是C++又说析构函数在程序执行之后才被自动调用，我的问题就是程序最后的"return 0"和析构函数谁先执行？还有就是全局实例构造函数的调用顺序又是怎么样的？

为了先得到结论，我用VS2008写了一段程序来实验这个问题。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include "stdafx.h"
#include <iostream>
#include <string>
 
using namespace std;
 
class Demo
{
public:
	string objName;
	Demo(string Name)
	{
		this->objName = Name;
		cout << objName << " Constructor called" << endl;
	}
	~Demo()
	{
		cout << objName << "Destructor called" << endl;
	}
};
 
Demo obj1("obj1");
 
int main()
{
	cout << "Main() start" << endl;
	Demo obj2("obj2");
	return int(&(cout << "Main() end" << endl));
}

最后的结果很奇怪，很奇怪...

obj1 Constructor called
Main() start
obj2 Constructor called
Main() end
obj2Destructor called
obj1Destructor called

1、全局实例的构造函数在main()之前被调用

2、析构函数都在main()之后被调用

悲剧了，第1个构造函数和最后2个析构函数居然不是main()来调用，那它们到底是谁调用的？显然在main()执行之前程序进行了一些列操作，至少包括全局变量的生成(因为全局变量是定义在堆上的)和main()参数的传递...暂时无视这个问题，欲知后事如何，请看下回分解...