Proxy Class

[spark valley]

@finite gull has reached level 1. GG!

[fossil halo]

Its similar to the Adapter design pattern. The name really already explains most of it. It is a proxy class that handles access to another object/class and is usually used if there needs to be simplified interface that the proxy can offer or if the underlying resource requires a lot of tracking/manual handling etc. so that way the proxy class can take care of all the nasty stuff, check if it is used correctly and forward function calls etc. to the underlying class while offering a nicer to use interface.

[finite gull]

and how should it be implemented? do you have an example?

[clear hatch]

is this for school or something?

[finite gull]

Yes, I would like to implement a proxy class

[clear hatch]

ask your teacher what they mean by proxy class

[finite gull]

Yes, but I also prefer to learn on my own. There are many students who ask the teacher questions. Sometimes, he doesn't have much time to answer my questions. That's why I'm calling on you 🙂

Moreover, it’s a subject we haven’t seen in class. They want us to learn it by informing ourselves.

[clear hatch]

A proxy class is a very loose term, it doesn't have a strict definition or strict implementation, it would depend on the context

[finite gull]

I just want a small example to know how to implement it in my program

[spark valley]

@finite gull has reached level 2. GG!

[clear hatch]

to solve what?

[finite gull]

Solve a problem of data storage in a memory

[clear hatch]

can you give more information?

[finite gull]

An example or explanatory links if you have any. That would help me a lot.

[finite gull]

I would like to put 2-byte values ​​into memory with an operator overload. The problem is that the function must return a modifiable variable, therefore an n-bit reference. One of the only solutions found is to create a proxy class.

[clear hatch]

I'd probably define a proxy class as a class that has the same interface as an other class but that wraps another class to provide a different access or behaviour

[clear hatch]

what operator overload?

[finite gull]

An operator overload by indexing (since I created an array allocated with new and delete).

[clear hatch]

you could just return a reference to std::int16_t

that's 2 bytes

[finite gull]

Yes, I have to mention that the value is uint16 and the memory is a uint8. So, I split the bits into 2 and then made a masking

[clear hatch]

so what's the issue?

[finite gull]

I need to overload the [] operator to be able to do mem[100] = 1234; and have it properly store 2 bytes in little-endian format in a uint8_t array.

The problem is that I need to return a modifiable reference (uint16_t&), but since the data is in two separate bytes, I don't see how to do it properly.

[clear hatch]

what's the type of mem?

[finite gull]

Uint8_t

[clear hatch]

no it's not

you can't use [] on uint8_t ^^

[finite gull]

Why ?

[clear hatch]

it's just not an option

it wouldn't compile

[finite gull]

What operator overload if it does not use [] ?

[clear hatch]

what's the type of mem

[finite gull]

mem is a pointer to the array of uint8

[clear hatch]

alright

so std::uint8_t*

now that makes sense

you could just return (std::uint16_t&)mem[index]

[finite gull]

Yes, but the variable will not be modifiable?

[clear hatch]

why not?

[finite gull]

but after that I will get an error: the initial value of a non-constant reference must be an lvalue?

Operator overloading should allow reading and writing the byte in the array. This is the reason why it does not work.

My classmates advised me to use proxy, as it was much easier

[clear hatch]

show me the code, what I sent should work

[finite gull]

The problem is that I don't have the right to share it in a public channel, sorry. 😅

[spark valley]

@finite gull has reached level 3. GG!

[clear hatch]

it'd be like

std::uint16_t& operator[] (std::size_t index)
{
  return (std::uint16_t&)mem[index];
}

[finite gull]

Yes, that's it, but in the function we have to read and write the 2-byte value in the array. Then we add functions like push and pop.

[clear hatch]

so what's the problem with this funciton?

[finite gull]

I need to overload the [] operator so that I can do something like mem[100] = 1234;, and have it correctly store 2 bytes in little-endian format in a uint8_t array.

The issue is that I need to return a modifiable reference (uint16_t&), but since the data spans two separate bytes, I’m not sure how to do it cleanly.

[clear hatch]

the code I sent above does that

[finite gull]

This function must have both read and write together.

[clear hatch]

yes

that's what it does

[finite gull]

How do you convert the value to uint16&?

[clear hatch]

(std::uint16_t&)

technically this would be a reinterpret_cast

[finite gull]

Yes but I don't know how to use it

[clear hatch]

you use it like this

[finite gull]

and so if I want to push and pop 2 functions based on operator overloading, will it work?

[fossil halo]

Its more of an Architecutural / Desing Pattern. It is not concerned with implementation too much. But I could give you an example, sure: c++ class SMTPClient { public: SMTPClient(std::string user, std::string password, std::string server); void sendEmail(std::string title, std::string message, std::string recipient); private: LowLevelSSLSocket soc; }; this would a spin for a more complex "Proxy-Class" but in the end it only functions as a proxy to the low level socket or another networking library. This probably isn't the cleanest example though.

[clear hatch]

what do you mean push and pop functions?

[fossil halo]

this could then also make use of RAII and use the destructor to close the socket again for example. As I understand the design pattern it is really just a "wrapper" around a resource that would otherwise be hard to handle

but I will make sure to read up on it myself later again and possibly correct myself ^^

[finite gull]

If I want to call the overloaded operator function and use it with push to add a value to the array — for example push: this->operator = value;

[finite gull]

Thank you

[clear hatch]

sure?

[finite gull]

Ok

[finite gull]

I have one last quick question: when reading and writing uint16_t values in a uint8_t array, is the usual method to mask, increment by 1, and then combine the bytes?

[fossil halo]

i found this video: https://youtu.be/nKYUdgLfCO0 (didn't watch yet)

[clear hatch]

not really, it's common to just reinterpret_cast or bit_cast/memcpy

[fossil halo]

sorry I didn't get that question.

[finite gull]

When reading and writing uint16_t values into a uint8_t array, is the usual method to use bitwise operations like masking with &, combining with |, and incrementing the index by 1 to access the second byte?

[clear hatch]

you can do it with bitshift and OR but in this case you don't need to

[fossil halo]

ah I see. This should rarely happen. For me this would indicate some design mismatch between 2 systems. One that requires uint16_t values and one that requires uint8_t values ... you can split the values using bit shifts into 2 values for sure. But to me this would indicate some logic flaw somewhere else.

[clear hatch]

it's because they are representing some memory, they are likely doing a toy VM or something like that

[fossil halo]

but I guess just reinterpret_cast ing it would be the preferred solution

or using a union

[clear hatch]

no an union is worst

and definitely UB

[finite gull]

So my solution would not be ideal ? for example : If my 16-bit variable is foo, then foo & 0xff gives me the lower 8 bits, and (foo & 0xff00) >> 8 gives me the upper 8 bits. To combine them again, I would use foo = foolow | (foohigh << 8)

[clear hatch]

that's fine too

[fossil halo]

that might be, but very convenient to use. And since it doesn't have a type index it should in theory always work even if it is technically UB

[clear hatch]

the only reason it works is because compilers agreed to let it work

[finite gull]

So if I implement this in 2 operator functions: 1 read and the other write, is that correct?

[spark valley]

@finite gull has reached level 4. GG!

[clear hatch]

that's fine but then you can't return a reference

[fossil halo]

sure. Yeah, you probably shouldn't use it. It's just my lazy thinking ^^

[finite gull]

yes, but if I use your suggestion will it be correct? (std::uint16&)

[fossil halo]

But same applies to many other things we use daily like #pragma once it's never been in the standard, but still works on all major compilers

in theory a compiler could just ignore it

[spark valley]

@fossil halo has reached level 4. GG!

[finite gull]

Would it be possible if I send my code privately?

[clear hatch]

sure