缺少operator=的类在MFC工程中不报错，在控制台工程中就报错？

Question

相同代码在MFC中不报错，在控制台工程中就报错
废话不多说直接看代码
库的头文件，问题就在GetUSBConfig这个函数的返回类型

class CCyUSBDevice
{
// The public members are accessible (i.e. corruptible) by the user of the library
// Algorithms of the class don't rely on any public members.  Instead, they use the
// private members of the class for their calculations.

public:

  CCyUSBDevice(HANDLE hnd = NULL, GUID guid = CYUSBDRV_GUID, BOOL bOpen = true);
  ~CCyUSBDevice(void);

  CCyUSBEndPoint      **EndPoints;     // Shortcut to USBCfgs[CfgNum]->Interfaces[IntfcIndex]->Endpoints
  CCyUSBEndPoint       *EndPointOf(UCHAR addr);

  CCyControlEndPoint   *ControlEndPt;
  CCyIsocEndPoint      *IsocInEndPt;
  CCyIsocEndPoint      *IsocOutEndPt;
  CCyBulkEndPoint      *BulkInEndPt;
  CCyBulkEndPoint      *BulkOutEndPt;
  CCyInterruptEndPoint *InterruptInEndPt;
  CCyInterruptEndPoint *InterruptOutEndPt;

  USHORT                StrLangID;
  ULONG                 UsbdStatus;
  ULONG                 NtStatus;
  ULONG                 DriverVersion;
  ULONG                 USBDIVersion;
  char                  DeviceName[USB_STRING_MAXLEN];
  char                  FriendlyName[USB_STRING_MAXLEN];
  wchar_t               Manufacturer[USB_STRING_MAXLEN];
  wchar_t               Product[USB_STRING_MAXLEN];
  wchar_t               SerialNumber[USB_STRING_MAXLEN];

  CHAR                  DevPath[USB_STRING_MAXLEN];

  USHORT                BcdUSB;
  USHORT                VendorID;
  USHORT                ProductID;
  UCHAR                 USBAddress;
  UCHAR                 DevClass;
  UCHAR                 DevSubClass;
  UCHAR                 DevProtocol;
  UCHAR                 MaxPacketSize;
  USHORT                BcdDevice;

  UCHAR                 ConfigValue;
  UCHAR                 ConfigAttrib;
  UCHAR                 MaxPower;

  UCHAR                 IntfcClass;
  UCHAR                 IntfcSubClass;
  UCHAR                 IntfcProtocol;
  bool                  bHighSpeed;

  DWORD                 BytesXfered;


  UCHAR                 DeviceCount(void);
  UCHAR                 ConfigCount(void);
  UCHAR                 IntfcCount(void);
  UCHAR                 AltIntfcCount(void);
  UCHAR                 EndPointCount(void);

  UCHAR                 Config(void)     { return CfgNum; }    // Normally 0
  void                  SetConfig(UCHAR cfg);

  UCHAR                 Interface(void)  { return IntfcNum; }  // Usually 0
                        // No SetInterface method since only 1 intfc per device (per Windows)

  UCHAR                 AltIntfc(void);
  bool                  SetAltIntfc(UCHAR alt);

  GUID                  DriverGUID(void) { return DrvGuid; }
  HANDLE                DeviceHandle(void) { return hDevice; }
  void                  UsbdStatusString(ULONG stat, PCHAR s);
  bool                  CreateHandle(UCHAR dev);
  void                  DestroyHandle();


  bool                  Open(UCHAR dev);
  void                  Close(void);
  bool                  Reset(void);
  bool                  ReConnect(void);
  bool                  Suspend(void);
  bool                  Resume(void);
  bool                  IsOpen(void)      { return (hDevice != INVALID_HANDLE_VALUE); }

  UCHAR                 PowerState(void);


  void                  GetDeviceDescriptor(PUSB_DEVICE_DESCRIPTOR descr);
  void                  GetConfigDescriptor(PUSB_CONFIGURATION_DESCRIPTOR descr);
  void                  GetIntfcDescriptor(PUSB_INTERFACE_DESCRIPTOR descr);
  CCyUSBConfig          GetUSBConfig(int index);


private:

  USB_DEVICE_DESCRIPTOR         USBDeviceDescriptor;
  PUSB_CONFIGURATION_DESCRIPTOR USBConfigDescriptors[2];

  CCyUSBConfig                 *USBCfgs[2];

  HANDLE                        hWnd;
  HANDLE                        hDevice;
  HANDLE                        hDevNotification;
  HANDLE                        hHndNotification;

  GUID                          DrvGuid;

  UCHAR                         Devices;
  UCHAR                         Interfaces;
  UCHAR                         AltInterfaces;
  UCHAR                         Configs;

  UCHAR                         DevNum;
  UCHAR                         CfgNum;
  UCHAR                         IntfcNum;     // The current selected interface's bInterfaceNumber
  UCHAR                         IntfcIndex;   // The entry in the Config's interfaces table matching to IntfcNum and AltSetting

  void                          GetDevDescriptor(void);
  void                          GetCfgDescriptor(int descIndex);
  void                          GetString(wchar_t *s, UCHAR sIndex);
  void                          SetStringDescrLanguage(void);
  void                          SetAltIntfcParams(UCHAR alt);
  bool                          IoControl(ULONG cmd, PUCHAR buf, ULONG len);

  void                          SetEndPointPtrs(void);
  void                          GetDeviceName(void);
  void                          GetFriendlyName(void);
  void                          GetDriverVer(void);
  void                          GetUSBDIVer(void);
  void                          GetSpeed(void);
  void                          GetUSBAddress(void);
  //void                          CloseEndPtHandles(void);

  bool                          RegisterForPnpEvents(HANDLE h);
};

CCyUSBConfig类

class CCyUSBConfig
{
private:

protected:
public:
  CCyUSBInterface *Interfaces[MAX_INTERFACES];

  UCHAR bLength;
  UCHAR bDescriptorType;
  USHORT wTotalLength;
  UCHAR bNumInterfaces;
  UCHAR bConfigurationValue;
  UCHAR iConfiguration;
  UCHAR bmAttributes;
  UCHAR MaxPower;

  UCHAR AltInterfaces;


  CCyUSBConfig(void);
  CCyUSBConfig(CCyUSBConfig& cfg);  // Copy Constructor
  CCyUSBConfig(HANDLE h, PUSB_CONFIGURATION_DESCRIPTOR pConfigDescr);
  ~CCyUSBConfig(void);



};

使用的代码

    CCyUSBDevice* USBDevice = new  CCyUSBDevice(NULL);
    char buf[512];
    std::string s;

    for (int c = 0; c < USBDevice->ConfigCount(); c++)
    {
        CCyUSBConfig cfg = USBDevice->GetUSBConfig(c);

        sprintf_s(buf, "bLength: 0x%x\n", cfg.bLength); s.append(buf);

        sprintf_s(buf, "bDescriptorType: %d\n", cfg.bDescriptorType); s.append(buf);

        sprintf_s(buf, "wTotalLength: %d (0x%x)\n", cfg.wTotalLength, cfg.wTotalLength);

        s.append(buf);

        sprintf_s(buf, "bNumInterfaces: %d\n", cfg.bNumInterfaces); s.append(buf);

        sprintf_s(buf, "bConfigurationValue: %d\n", cfg.bConfigurationValue); s.append(buf);

        sprintf_s(buf, "iConfiguration: %d\n", cfg.iConfiguration); s.append(buf);

        sprintf_s(buf, "bmAttributes: 0x%x\n", cfg.bmAttributes); s.append(buf);

        sprintf_s(buf, "MaxPower: %d\n", cfg.MaxPower); s.append(buf);

        s.append("**********************************\n");

        std::cout << s;

        s.clear();

        for (int i = 0; i < cfg.AltInterfaces; i++)
        {
            CCyUSBInterface* ifc = cfg.Interfaces[i];

            sprintf_s(buf, "Interface  Descriptor:%d\n", (i + 1)); s.append(buf);

            sprintf_s(buf, "--------------------------------\n"); s.append(buf);

            sprintf_s(buf, "bLength: 0x%x\n", ifc->bLength); s.append(buf);

            sprintf_s(buf, "bDescriptorType: %d\n", ifc->bDescriptorType); s.append(buf);

            sprintf_s(buf, "bInterfaceNumber: %d\n", ifc->bInterfaceNumber); s.append(buf);

            sprintf_s(buf, "bAlternateSetting: %d\n", ifc->bAlternateSetting); s.append(buf);

            sprintf_s(buf, "bNumEndpoints: %d\n", ifc->bNumEndpoints); s.append(buf);

            sprintf_s(buf, "bInterfaceClass: %d\n", ifc->bInterfaceClass); s.append(buf);

            sprintf_s(buf, "**********************************\n"); s.append(buf);

            std::cout << s;

            s.clear();

            for (int e = 0; e < ifc->bNumEndpoints; e++)
            {
                CCyUSBEndPoint* ept = ifc->EndPoints[e + 1];

                sprintf_s(buf, "EndPoint  Descriptor:%d\n", (e + 1)); s.append(buf);

                sprintf_s(buf, "--------------------------------\n"); s.append(buf);

                sprintf_s(buf, "bLength: 0x%x\n", ept->DscLen); s.append(buf);

                sprintf_s(buf, "bDescriptorType: %d\n", ept->DscType); s.append(buf);

                sprintf_s(buf, "bEndpointAddress: 0x%x\n", ept->Address); s.append(buf);

                sprintf_s(buf, "bmAttributes: 0x%x\n", ept->Attributes); s.append(buf);

                sprintf_s(buf, "wMaxPacketSize: %d\n", ept->MaxPktSize); s.append(buf);

                sprintf_s(buf, "bInterval: %d\n", ept->Interval); s.append(buf);

                s.append("**********************************\n");

                std::cout << s;

                s.clear();
            }

        }

    }

报错点，控制台工程中报错

MFC中就不报错

问题其实很简单，就是CCyUSBConfig类没有重写operator=，但是为什么MFC工程中就不报错呢？

Answer 1

引自免费微信小程序：皆我百晓生

在MFC工程中不报错的原因可能是MFC工程中的某些设置或特性使得编译器默认处理这种情况，但在控制台工程中由于缺少这些设置或特性，导致报错。当类被设计为不应使用其默认的复制构造函数时，就需要重写或禁止复制构造函数以防止不当行为发生。这种情况往往涉及到一些特定的编程实践和标准合规性问题。对于 CCyUSBConfig 类没有重写 operator= 的情况，以下是可能的解释和解决方案：

解释：

1. 编译器差异或设置差异：不同的编译器或编译器设置可能对复制构造函数的处理有不同的默认行为。例如，某些编译器可能默认提供浅拷贝的复制构造函数实现，但在其他编译器中可能没有这种默认行为。此外，不同的编译选项（如优化级别）也可能影响编译器如何处理这类问题。因此，这可能解释了为什么在同一个代码在MFC工程中和在控制台工程中会有不同的表现。
2. 使用场景不同：MFC框架中可能存在某种机制使得该错误没有被触发。这可能涉及到框架内部的某些特定操作或特定的使用场景，使得在没有重写 operator= 的情况下也能正常工作。但在独立的控制台应用程序中，由于缺乏这样的框架上下文，就会出现错误。

解决方案：

为了解决这个问题，你可以采取以下步骤：

1. 重写复制构造函数：如果你希望自定义类能够支持复制构造函数的使用，你可以显式地为其重写复制构造函数并提供自定义的复制行为。这样做有助于确保类状态的正确复制。例如：

class CCyUSBConfig {
    // ... 其他成员变量 ...
public:
    CCyUSBConfig(const CCyUSBConfig& other) {
        // 这里实现自定义的复制逻辑
    }
    // ... 其他成员函数 ...
};

1. 禁止复制构造函数的使用：如果你不希望类被复制，你可以声明复制构造函数为私有或删除它。这样可以防止类被意外复制。例如：

class CCyUSBConfig {
private: // 或者使用 "= delete" 来显式删除它
    CCyUSBConfig(const CCyUSBConfig&) = delete; // 删除复制构造函数的使用权限
    // ... 其他成员变量和成员函数 ...
};

1. 检查编译器和设置：确保在不同的环境中使用相同的编译器和编译选项。如果可能的话，尝试统一编译设置以确保代码在所有环境中都能正确编译。此外，查看编译器的文档或寻求在线资源，了解特定编译器如何处理此类问题，并根据需要进行调整。如果问题是由编译器设置引起的，可能需要调整这些设置以匹配期望的行为。

总之，为了解决这个问题并确保代码的健壮性，建议重写或删除 CCyUSBConfig 的复制构造函数，并根据需要进行适当的调整。