为什么这段代码B*b＝c不调用构造函数啊，而且没有delete c为啥会析构bc

#define _CRT_SECURE_NO_WARNINGS 1;
#include<iostream>
using namespace std;
void swap(int* a, int* b)
{
    int* c;
    c = a; a = b; b = c;
}
class A
{
public:
    
};

class B 
{
public:
    B() { cout << "B" << endl; }
    virtual void func()
    {
        cout << "B::f" << endl;
    }
    B( B* b) { cout << "B1" << endl; }
    virtual~B() { cout << "~B" << endl; }
};
class C :public B
{
public:
    C() { cout << "C" << endl; }
    virtual void func()
    {
        cout << "C::f" << endl;
    }
    ~C() { cout << "~C" << endl; }
};

int main()
{
    /*A a(0);
    cout << "---------"<<endl;
    A b(a);
    cout << "---------" << endl;
    A c(1);
    cout << "---------" << endl;
    A::func(b);
    cout << "---------" << endl;*/
    C*c=new C;
    B* b=c;
    delete b;
    //b->func();

}

如果是堆栈上的变量，在出了函数调用的时候，不需要 delete，也会调用析构函数的。
B * b = c; 这是指针，不需要拷贝

不知道你这个问题是否已经解决, 如果还没有解决的话:

• 以下回答来自chatgpt:

  问题分析： 这段代码 B *b = c 在语法上是不合法的，因为 = 是赋值操作符，而左边是一个指针类型 B*，右边是一个对象类型 c，它们的类型不匹配。正确的语法应该是 B *b = &c，即将对象 c 的地址赋值给指针 b。

  解决方案： 首先，将代码 B *b = c 修改为 B *b = &c。 另外，析构函数的调用一般需要手动调用 delete 来释放动态分配内存的对象，否则对象不会被析构。

  修改后的代码如下：

  class B {
  public:
    B() { cout << "Constructor called!" << endl; }
    ~B() { cout << "Destructor called!" << endl; }
  };
  
  int main() {
    B c;
    B *b = &c;
    // 使用 b 指向的对象
    // ...
    delete b; // 手动释放内存
    return 0;
  }
  

  这样就能够正确地调用构造函数和析构函数，并且通过 delete 释放了动态分配的对象。

如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^