转载自：http://www.cnblogs.com/chio/archive/2007/10/20/931043.html
题目如下：问下列代码的打印结果为0吗？



#include <stdlib.h>

#include <iostream>
using 
namespace std;

struct CLS

{

    int m_i;

    CLS( int i ) : m_i(i){}

    CLS()

    {

        CLS(0);

    }

};
int main()

{

    CLS obj;

    cout << obj.m_i
<< endl;


    system("PAUSE");

    return 
0;

}
打印结果是不定的，不一定为0


代码奇怪的地方在于构造函数中调用了自己的另一个构造函数


我们知道，当定义一个对象时，会按顺序做2件事情：

1）分配好内存（非静态数据成员是未初始化的）

2）调用构造函数（构造函数的本意就是初始化非静态数据成员）


显然上面代码中，CLS obj；这里已经为obj分配了内存，然后调用默认构造函数，但是默认构造函数还未执行完，却调用了另一个构造函数，这样相当于产生了一个匿名的临时CLS对象，它调用CLS(int)构造函数，将这个匿名临时对象自己的数据成员m_i初始化为0；但是obj的数据成员并没有得到初始化。于是obj的m_i是未初始化的，因此其值也是不确定的


从这里，我们归纳如下：

1）在c++里，由于构造函数允许有默认参数，使得这种构造函数调用构造函数来重用代码的需求大为减少

2）如果仅仅为了一个构造函数重用另一个构造函数的代码，那么完全可以把构造函数中的公共部分抽取出来定义一个成员函数(推荐为private),然后在每个需要这个代码的构造函数中调用该函数即可

3）偶尔我们还是希望在类的构造函数里调用另一个构造函数，可以按下面方式做：

在构造函数里调用另一个构造函数的关键是让第二个构造函数在第一次分配好的内存上执行，而不是分配新的内存，这个可以用标准库的placement new做到：
    先看看标准库中placement new的定义


inline void
*__cdecl 
operator new(size_t,
void *_P)

{

    return (_P);


} 
可见没有分配新的内存。


正确的方式：


struct CLS

{

    int m_i;

    CLS( int i ) : m_i(i){}

    CLS()

    {

        new (this)CLS(0);

    }

};
  


另： 若构造函数调用自身，则会出现无限递归调用，是不允许的

 

Linux作业-------有一个文件夹，下面有许多个C语言源程序。要求编写一个程序，统计所有C语言源程序中，下列系统函数的被调用次数。
printf  open  close  read  write  fork  signal

统计结果输出到myresult.txt文件按中，格式如下：

printf  49

open    13

close   13

read    24

write   16

fork     8

signal   0
介绍
1.主程序用来将九个.c文件中的内容统计到一个data.txt中，对八个.c文件生成一个子程序，读者可自行查看main.c源码及注释以了解细节，main.c make运行后可生成两个.txt文件，data.txt用来存储所有.c文件的文本信息，方便处理，myresult.txt用来显示最终统计结果，在main.c中主要需解决的问题是必须先创建好data.txt，这样才可重复调用rop()函数来实现每个文本的写入其中逻辑关系读者可自行查看上述main.c主函数的for循环内语句。

2. data.txt完成后再用shell编程进行结果输入到myresult.txt中，需用在输入语句sh shel,运行shel，shel中用echo的打印内容输出重定向到myresult.txt中，其中用强大的grep文本处理，-c表示仅列出包含模式的行数，由于需统计的函数均单处一行，所以此方法可行，同样输出重定向到myresult.txt中。

3. 在虚拟机中进行。
主程序—main.c
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <sys/wait.h>


void op(int fd,char s[]){
    fd=open(s,O_RDWR,0644);
    char buf[1024];

    int fd0;
    fd0=open("data.txt",O_CREAT | O_RDWR,0644);
    int flag;
    while(flag = read(fd,buf,strlen(buf)))
        write(fd0,buf,flag);		//将s[]读到的内容写入data.txt
    close(fd);
    close(fd0);
}	//创建data.txt用已存储.c文件内代码

void rop(int fd,int j,char s[]){
    fd=open(s,O_RDWR,0644);
    char buf[1024];

    int fd0;
    fd0=open("data.txt",O_CREAT | O_RDWR,0644);
    int flag;
    while(flag = read(fd,buf,strlen(buf)))
        write(fd0,buf,flag);
    close(fd);
    close(fd0);
}	//与上个函数类似，主要不同是加了j参数，用来实现lseek()指示写的位置

char *a[9]={"main1.c","a.c","b.c","d.c","func1.c","func2.c","mycopy.c","read.c","write.c"};
       //需要统计的.c文件名数组，用来传递name
int main(){
    int fd;
    pid_t pid;
    int i;
    int j=0;
    for(i=1;i<9;++i){
        sleep(1);		
        j += 1024;	//每次写入位置需要变化
        if((pid=fork())==0){
            
            break;
        }
    }
    if(pid==0){
        printf("son%d\n",i);	//指示生成几个子进程
        if(i==1)
            op(fd,a[i]);
        else
            rop(fd,j,a[i]);
    }else{
        op(fd,a[0]);
            
    }
    fd=open("myresult.txt",O_CREAT | O_RDWR,0644);		//生成myresult.txt用来存储最终结果
    close(fd);
    return 0;
}


一个简单的makefile

a: main.o

gcc main.o -o a


main.o: main.c

gcc main.c -c


clean:

rm *.o a *.txt






运用shell编程及grep处理文本
#!/bin/sh
  
echo "printf    \c ">>myresult.txt
grep -c "printf" data.txt>>myresult.txt
echo "open      \c">>myresult.txt
grep -c "open" data.txt>>myresult.txt
echo "close      \c">>myresult.txt
grep -c "close" data.txt>>myresult.txt
echo "read      \c">>myresult.txt
grep -c "read" data.txt>>myresult.txt
echo "write      \c">>myresult.txt
grep -c "write" data.txt>>myresult.txt
echo "fork      \c">>myresult.txt
grep -c "fork" data.txt>>myresult.txt
echo "signal      \c">>myresult.txt
grep -c "signal" data.txt>>myresult.txt
echo "pthread      \c">>myresult.txt
grep -c "pthread" data.txt>>myresult.txt
echo "scanf      \c">>myresult.txt
grep -c "scanf" data.txt>>myresult.txt

    
今天看了一道迅雷的笔试题目，然后引起一段思考，题目如下：
下列关于虚函数的说法正确的是（）
A、在构造函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效。
B、在析构函数中调用类自己的虚函数，虚函数的动态绑定机制还会生效。
C、静态函数不可以是虚函数
D、虚函数可以声明为inline

此题答案给的是BCD，当时我就产生很大疑惑，所以我对四个选项依依来验证。
1、首先对于AB选项，我做了如下代码：
 

 1 #include <iostream>
 2 using namespace std;
 3 class ClassA
 4 {
 5 public:
 6     ClassA()
 7     {
 8         cout<<"classA-begin"<<endl;
 9         OutPut();
10         cout<<"classA-endl"<<endl;
11     }
12     virtual ~ClassA()
13     {
14         cout<<"~classA-begin"<<endl;
15         OutPut();
16         cout<<"~classA-endl"<<endl;
17     }
18     void virtual OutPut()
19     {
20         cout<<"A"<<endl;
21     }
22 };
23 
24 class ClassB:public ClassA
25 {
26 public:
27     ClassB()
28     {
29         cout<<"ClassB-begin"<<endl;
30         OutPut();
31         cout<<"ClassB-endl"<<endl;
32     }
33     virtual ~ClassB()
34     {
35         cout<<"~ClassB-begin"<<endl;
36         OutPut();
37         cout<<"~ClassB-endl"<<endl;
38     }
39     void OutPut()
40     {
41         cout<<"B"<<endl;
42     }
43 
44 };
45 
46 
47 int main()
48 {
49  ClassA *a=new ClassB();
50  a->OutPut();
51  delete a;
52  getchar();
53  return 0;
54 
55 }

 
在vs2010中输出结果为：

可以看到，在new ClassB时，虽然在父类ClassA的构造函数调了的是被ClassB覆盖的虚函数Output()，但是实际上还是调用的ClassA的OutPut。这是因为
        继承类在构造的时候总是首先调用其基类的构造函数来对属于其基类的部分进行构造，在这个时候，整个类被当作基类来处理，继承类的部分对整个类来说好像不存在一样，直到基类的构造函数退出并进入继承类的构造函数，该类才被当作继承类来出来处理。对析构也一样，只是析构的顺序正好相反。
由此可知AB错误。（可以参考：http://www.cnblogs.com/xiaoxibo/archive/2011/07/18/2212612.html）
对于C选项：
  因为静态成员函数没有this，也就没有存放vptr的地方，同时其函数的指针存放也不同于一般的成员函数，其无法成为一个对象的虚函数的指针以实现由此带来的动态机制。静态是编译时期就必须确定的，虚函数是运行时期确定的。故C项正确。
对于D选项：
inline函数和virtual函数有着本质的区别，inline函数是在程序被编译时就展开，在函数调用处用整个函数体去替换，而virtual函数是在运行期才能够确定如何去调用的，因而inline函数体现的是一种编译期机制，virtual函数体现的是一种运行期机制。
因此，内联函数是个静态行为，而虚函数是个动态行为，他们之间是有矛盾的。
函数的inline属性是在编译时确定的， 然而，virtual的性质则是在运行时确定的，这两个不能同时存在，只能有一个选择，文件中声明inline关键字只是对编译器的建议，编译器是否采纳是编译器的事情。
我并不否认虚函数也同样可以用inline来修饰，但你必须使用对象来调用，因为对象是没有所谓多态的，多态只面向行为或者方法，但是C++编译器，无法保证一个内联的虚函数只会被对象调用，所以一般来说，编译器将会忽略掉所有的虚函数的内联属性。
所以D正确。
故此题答案为CD
 

转载于:https://www.cnblogs.com/yongbufangqi1988/p/3674121.html

题目如下：问下列代码的打印结果为0吗？


#include <stdlib.h>

#include <iostream>
using namespace std;

struct CLS

{

    int m_i;

    CLS( int i ) : m_i(i){}

    CLS()

    {

        CLS(0);

    }

};
int main()

{

    CLS obj;

    cout << obj.m_i << endl;


    system("PAUSE");

    return 0;

}
打印结果是不定的，不一定为0


代码奇怪的地方在于构造函数中调用了自己的另一个构造函数


我们知道，当定义一个对象时，会按顺序做2件事情：

1）分配好内存（非静态数据成员是未初始化的）

2）调用构造函数（构造函数的本意就是初始化非静态数据成员）


显然上面代码中，CLS obj；这里已经为obj分配了内存，然后调用默认构造函数，但是默认构造函数还未执行完，却调用了另一个构造函数，这样相当于产生了一个匿名的临时CLS对象，它调用CLS(int)构造函数，将这个匿名临时对象自己的数据成员m_i初始化为0；但是obj的数据成员并没有得到初始化。于是obj的m_i是未初始化的，因此其值也是不确定的


从这里，我们归纳如下：

1）在c++里，由于构造函数允许有默认参数，使得这种构造函数调用构造函数来重用代码的需求大为减少

2）如果仅仅为了一个构造函数重用另一个构造函数的代码，那么完全可以把构造函数中的公共部分抽取出来定义一个成员函数(推荐为private),然后在每个需要这个代码的构造函数中调用该函数即可

3）偶尔我们还是希望在类的构造函数里调用另一个构造函数，可以按下面方式做：

在构造函数里调用另一个构造函数的关键是让第二个构造函数在第一次分配好的内存上执行，而不是分配新的内存，这个可以用标准库的placement new做到：
    先看看标准库中placement new的定义


inline void *__cdecl operator new(size_t, void *_P)

{

    return (_P); 

} 
可见没有分配新的内存。


正确的方式：


struct CLS

{

    int m_i;

    CLS( int i ) : m_i(i){}

    CLS()

    {

        new (this)CLS(0);

    }

};
  

另： 若构造函数调用自身，则会出现无限递归调用，是不允许的
转自 http://www.cnblogs.com/chio/archive/2007/10/20/931043.html