精华内容
下载资源
问答
  • 转载自:... 题目如下:问下列代码的打印结果为0吗? #include stdlib.h> #include iostream> using namespace std; struct CLS {  int m_i;  CLS( int i

    转载自: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);
        }
    };

     


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

     

    展开全文
  • 要求编写一个程序,统计所有C语言源程序下列系统函数的被调用次数。 printf open close read write fork signal 统计结果输出到myresult.txt文件按,格式如下: printf 49 open 13 close 13 read 24 write 16....

    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、虚函数可以...

    今天看了一道迅雷的笔试题目,然后引起一段思考,题目如下:

    下列关于虚函数的说法正确的是()
    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);  }...
    题目如下:问下列代码的打印结果为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




    展开全文
  • 调用函数调用函数返回值

    千次阅读 2011-10-14 08:55:34
    一般使用return语句由被调用函数调用函数返回值,该语句有下列用途: 1.它能立即从所在的函数中退出, 返回到调用它的程序去。 2.返回一个值给调用它的函数。 有两种方法可以终止子函数运行并返回到调用它的函数...
  • 从一道题谈C++构造函数调用构造函数 题目如下:问下列代码的打印结果为0吗? #include stdlib.h> #include iostream> using namespace std; struct CLS {  int m_i;  CLS( int i...
  • 指用一系列的函数来解决问题函数的可重入性:可重入是指一个函数传的参数一定,则结果必须一定要求:def 定义的函数不要访问除局部变量以外的变量高阶函数 high order function什么是高阶函数:满足下列一个条件的...
  • 转自:... 题目如下:问下列代码的打印结果为0吗? #include stdlib.h> #include iostream> using namespace std; struct CLS {  int m_i;  CLS( int 
  • 原文链接:... 今天去一家公司面试,笔试碰到一个题,觉得有些意思,自己当时其实也没有完全搞清楚,这里跟大家分享一下,也算是自己做个笔记 题目如下:问下列代码的打印结果为0吗?
  • matlab 函数调用

    千次阅读 2012-01-03 16:32:59
    主函数 每个M文件的第一个函数为主函数,主函数可以被该文件之外的其它函数调用。 主函数可以调用文件外的函数和文件内的子函数。...一个M文件可以包含多个函数,...一个嵌套函数可以被下列函数调用。 (1)该嵌
  • GetChild()是我自定义的函数,有一个输入参数 下列语句 select No_Hospital from GetChild('10001') 就是正确的,但是如果我写成这样子就提示有错误: select No_Hospital from GetChild(select choscode from...
  • 今天在面试的时候,写了一个类,自己在另一个构造函数中调用了另一个构造函数,面试官说,这样不行吧,你回去查查。 后来回来一查,果然我写的有问题。下面一篇文章写的很好详细,我这里转过来,原文来自这里:...
  • 原文链接:... 题目如下:问下列代码的打印结果为0吗? #include stdlib.h> #include iostream> using namespace std; struct CLS {  int m_i;  CLS( int i ) : m_i(i)

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,514
精华内容 605
关键字:

下列函数调用中