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

Question

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

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

下面请找我的代码：

主要：

#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;    
}

我应该将上面的内容用作Public类还是将其添加为友元类，还是仅仅用作外部变量？

Answer 1

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

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

%s仅用于C字符串（即空终止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甚至是一个更好的选择？