Thread: using facet to covert from encoding to encoding

using the example from cppreference:
std::codecvt - cppreference.com

I've managed to convert from utf-8 to utf-32. here is my code:

Code:

template<class Facet>
struct deletable_facet : Facet
{
    template<class ...Args>
    deletable_facet(Args&& ...args) : Facet(std::forward<Args>(args)...) {}
    ~deletable_facet() {}
};

int main(){

    std::string data = "hello world";

    std::wstring_convert<deletable_facet<std::codecvt<char32_t, char, std::mbstate_t>>, char32_t> toUTF32Convertor;
    std::u32string str32 = toUTF32Convertor.from_bytes(data);
}

it works with this example, but I wanted to ask few questions:
1) is this code valid? it works for "hello world" example, yes, but I wonder if it's a one-time charm or is it actually functioning like it should.
2) I don't get the whole "inherit from unknown Facet class and move all the arguments to the base constructor"
3) I don't get the whole "inherit from std::codecvt", why do we need to inherit from coedcvt at the first place?
(4- why couldn't we get some nicer API :-) ?)

Originally Posted by phantomotap

O_o

Yes. Strangely, the code would be valid even if the resulting executable didn't work.

The "it works" bit is a quality of implementation issue.

A shipping implementation of the standard library just doesn't have to provide the relevant `std::codecvt<???>` specialization.

I don't understand your answer. will the code convert correctly from utf8 to utf32 (assuming you put valid utf8 strings to it)?

Originally Posted by phantomotap

I don't know why you really just asked the same question twice.

Why wouldn't you use a standard mechanism for the conversion? The use of standard components explains why you are using the `std::codecvt<???>` template class, and the use of idiomatic C++ techniques within the fledgling C++ standard library explains the wrapper. The `std::codecvt<???>` template class was designed to be used in specific circumstances essentially protecting the class by preventing a client from trying certain bits of nonsense. The derived class really just exposes the destructor for use by a client.

they are not the same question. the first question is - what benefit do we get from inheriting and not adding any functionallity?

Code:

class A{int x; }; class B : public A{};

what does B gives us that A doesn't? why did we needed this step in the first place? this is just strange that someone decided to inherit from one class, add no functionality and put it as a valid argument to a standard class .

the second question is : where in the documentation is it said you should put anything other then std::codecvt as template argument?

Originally Posted by phantomotap

You could always write convenience interfaces over the library components, but you can't really add functionality to an implementation unless the interfaces are capable of expressing the extra functionality.

People who ask for simpler localization interfaces usually don't understand the complexity inherent in localization.

The fact is that, despite the richness of the offered components, the standard library isn't really sophisticated enough to handle some real world requirements.

Soma

can you allaborate on this?

ok.
Anyone else want to join and explain?

thanks you both.
I get it now.