请教3个C++的问题

[stucsz]

1.有如下程序段：

class A
{
  public:
    A(){printf(" A");}
    A(const A& a) {printf(" COPYCONSTRUCTOR ");}
   ~A(){printf(" ~A");}
};

class B
{
  public:
    B(A &a)
    {  printf(" B");  _a=a; }
    ~B(){printf(" ~B");}
  private:
    A _a;
};

int main()
{
   A a;
   B b(a);
}

在上面的程序中，A a 会调用一次构造函数，然后B b(a)语句中，B中的类A的私有变量_a会调用拷贝构造函数来执行语句_a=a，最后b本身的构造函数也会被调用。这样的话，调用的构造函数依次应该是A COPYCONSTRUCTOR B,但是程序却输出A A B，我先问一下以上哪一点分析错了。

2.对于程序段：

class C
{
    public:
      C(){printf("0");}
      C(int c){printf("1");}
      C& operator=(const C& c)     { printf("2"); return *this;}
      ~C(){printf("~C  ");}
};

int main()
{
    C c1=10;
}

对于C c1=10；会自动调用参数是整型的构造函数生成一个匿名对象，然后用这个匿名对象去对c1进行拷贝构造函数的调用。 而且我从别的书上看到说，匿名对象也要调用构造函数和析构函数。那么这样的话，这个程序就应该调用两次析构函数，一次是匿名对象的，一次是c1的，那么程序就应该输出1 ~C ~C。但是程序输出的是1 ~C，我想问一下上面的分析有什么不正确的地方？

3.对于程序

class A
{
   public:
    void foo( )
    {
      run(func);
    }
    void run(PFN pfn)      {pfn( );}
    void  (*func) ( )       {printf("run");}
};
int main()
{
    A a;
    a.foo();
}

我想问一下程序应该怎样修改才能编译通过呢？

[adventurelw]

B(A &a)
{ printf(" B"); _a=a; }
第一个问题
_a = a不是复制构造，是赋值操作。
_a会调用默认构造函数生成一个对象，然后通过你的赋值操作获得a的内容
要达到你的目的，需要这样写
B(A &a) : _a(a)
{ printf(" B"); }

[goodname]

问题1
_a=a;的时候应该调用的是operator=操作

而B的构造函数没有，所以编译器生成缺省的构造函数，该函数执行成员构造，所以_a的缺省构造函数执行了。

[adventurelw]

第二个问题应该是编译器的优化问题，确实应该是一个临时对象，一次复制构造的。
你可以显式定义复制构造函数，是看不到调用复制构造函数的过程的。

[adventurelw]

第三个问题，函数指针实际在传递的时候，直接使用函数名就是函数指针。
因为不懂PFN pfn是个什么东西，所以不是太明白楼主的思路
很少用到这个，不知道改得对不对

class A
{
   public:
   typedef void (*func)();
   void  Func( )       {printf("run");}
   void run(func pfn)      { pfn( );}
   void foo( )
    {
      run(func);
    }    
};
int main()
{
    A a;
    a.foo();
}

[woods2001]

程序1中
对于B中的私有成员_a 她是一个类型A的对象
然后在构造函数中
B(A &a)
{ printf(" B"); _a=a; }
你看看operator= 有没有重载呢
你只写了一个 A的构造函数
A(const A& a) {printf(" COPYCONSTRUCTOR ");}

所以才会有错误的

[lpf000]

C c1=10;//不是利用构造函数进行类型转换，而是隐式调用构造函数初始化
就是 相当于C c1(10)而已

[goodname]

第三个问题有些悖论，也许我理解错了，无良方。

再考虑考虑。

[lzh9955]

无穷无尽的细节,累啊!

[red_berries]

问题1修改成
class B
{
public:
B(A &a):_a(a)
{ printf(" B");
}
~B(){printf(" ~B");}
private:
A _a;
};
就可以按lz的要求输出了,原因上面的已经说清楚了
问题2
C c1=10 直接调用C(int)的构造函数

问题3
调用类的成员函数一定要指定对应的对象或对象指针,下面的可以编绎通过

class A
{
public:
	typedef void (A::*PFN)();

	void foo( )
	{
		run(&A::func);
	}

	void run(PFN pfn)      
	{
		(this->*pfn)();
	}

	void func()       
	{
		printf("run");
	}
};
int main()
{
	A a;
	a.foo();
}

[Sou2012]

学习了！！

[pengzhixi]

B(A &a)
{ printf(" B"); _a=a; }
首先在执行printf语句之前,_a成员会先被编译器构造出来.然后_a=a会调用A的operator=运算符.
C c1=10；你这个不会生成匿名对象,会直接调用构造函数,因为你的构造函数没有被声明为explicit的

[ex_dijkstra]

mark，跟着学习一下

[xiao0915]

[Quote=引用 1 楼 adventurelw 的回复:]
B(A &a)
{ printf(" B"); _a=a; }
第一个问题
_a = a不是复制构造，是赋值操作。
_a会调用默认构造函数生成一个对象，然后通过你的赋值操作获得a的内容
要达到你的目的，需要这样写
B(A &a) : _a(a)
{ printf(" B"); }
[/Quote]

初始化列表的使用

初始化不是赋值