如何在另一个类中使用类成员的正确方法？

Question

我正在尝试使用来自不同类的类成员，将“class uart”添加到“class parser : public uart”

但是我不能在解析器类中使用成员变量，例如（缓冲区大小、缓冲区或状态枚举值没有改变或更新）我可以使用这些变量的唯一方法是将它们用作外部变量，但我会喜欢以班级成员的方式来做。

请在下面找到我的代码：

主要：

#include <stdio.h>
#include "parser.h"
int main()
{
    parser m_parser;
    m_parser.test();
    return 0;
}

uart.h

#include <stdint.h>
#include <stdio.h>

//extern uint16_t buffer_size;
//extern char buffer[1024];

class uart
{
public:
    // Construction
    uart();

    //..... some functions
    void Initialize();

    //members
    enum STATE_enum
    {
        Buffering_message=0,
        Message_received,
        Buffering_empty
    };
    STATE_enum state;

    uint16_t buffer_size;
    char buffer[1024];
protected:
    //  static void UARTHandler(app_uart_evt_t * p_event);
    void Message();
    // Singleton instance
    static uart * m_instance;
};

uart.cpp

#include "uart.h"
//uint16_t buffer_size=0;
//char buffer[1024];

uart * uart::m_instance = 0; // Singleton instance

uart::uart()// Construction
{
    state = Buffering_empty;
    m_instance = this;
}

void uart::Initialize()
{
}
/*void UART::UARTHandler(app_uart_evt_t * p_event)
{
    Message();
}*/
void uart::Message()
{
    uint8_t value;
//  while ((app_uart_get(&value)) == NRF_SUCCESS) //specific function from my microcontroller stack for reading RX bytes
    {
        if(value == 0x0A ) // message end /r
            state = Message_received;
    }       
    switch (state)
    {
        case Message_received:
                printf("message:[%s] buffer_size:[%d]", buffer,buffer_size); //printf fine from there
        break;      
        case Buffering_message:
                buffer[buffer_size++] = value;              
        break;
        default:
        break;      
    }       
}

parser.h

#include <stdio.h>
#include <stdint.h>
#include "uart.h"

class parser : public uart
{
public: 
    parser();

    void test();
    static parser * m_instance; 

    static inline parser & Instance()// Singleton access
    {
        return *m_instance;
    }       
};

parser.cpp

#include "parser.h"

class parser * parser::m_instance = 0;

// Constructor
parser::parser()
{
    m_instance = this;
}

void parser::test()
{       
    printf("state %s", state); // sending AT command

//  memset(buffer, 0, buffer_size); 
//  buffer_size = 0;    
}

我应该将上面的作为公共类使用还是添加为朋友类，或者只是用作外部变量？

Answer 1

最初的问题显然是使用了错误的格式说明符：

void parser::test()
{       
    printf("state %s", state);
    //            ^^
}

%s 仅用于 C 字符串（即以 null 结尾的 char 数组）。在这里，state 被解释为一个指针，但它指向无效的地址（未定义的行为），因此您的应用程序可能在它能够产生任何输出之前就崩溃了。

即使state 确实包含一个有效的地址，你仍然会遭受未定义的行为，因为%s需要char*类型的参数（为了避免UB，你需要强制转换） .

使用正确的格式说明符来解决问题：

printf("state %u", static_cast<unsigned int>(state));

您仍然需要强制转换以避免 UB，因为 %u 需要 unsigned int，但您的枚举不是（或者您可以使用 %d 并强制转换为 int）。

显然，您现在也尝试（因为没有发现实际错误）通过使用单例来解决您假设的问题 - 不幸的是，通过糟糕地实现该模式，您你的设计有缺陷。

如何修复？首先，丢弃单例。在特定情况下绝对不需要。然后三思而后行（以下已经是一个问题之前）：解析器真的是 UART 吗？不考虑代码，但考虑概念，我明确地说“不”。所以你也不应该让parser 继承 uart。而是让它聚合一个：

class parser // : public uart
{
    uart m_uart;
public:
    // ...
    void test()
    {
        printf("%u", static_cast<unsigned int>(m_uart.state);
    }

};

或者，您可以通过指针或引用（对构造函数）在外部提供它并按原样存储它，但是您很快也会遇到生命周期管理，我建议您返回更高级的概念再多一点经验...

你应该习惯，但是：封装。不要公开成员变量，除非您真的希望它们可以从任何地方更改。例如，buffer 是私有（甚至不受保护）的热门候选。

最后buffer_size：如果你打算用它来计算缓冲区中当前的值的数量，那很好。如果它代表可以存储的最大数据数，那么它是冗余的。无论您在哪里需要它，都可以通过sizeof(buffer)/sizeof(*buffer) 获取大小（除非数组已衰减为指针！）。除以第一个元素的大小是必要的，因为sizeof 总是以字节为单位提供大小，而不是元素的数量。

元素数量的大小是你通过std::array::size得到的；由于高级界面，您应该更喜欢 std::array 而不是原始数组！也许std::vector 甚至是更好的选择？