so you can't get the context of the class

just remove the classname:: and it will be fine

also, give "getConWords()" a return type

I told you what to do

now, tell me how that changed the compiler errors

probably an encoding issue?

no

had something similar long time ago

look at the constructor

like. closely

look at how you call the functions

Shouldn't it be ()?

also, give your functions return types

Shouldn't it be ()?

He shouldnt give a return type when calling a function and shouldnt call the function anonymously

Ok

but he doesn't listen

My teacher told me that I can use my calculator to compute variations

It's awesome

lol you can xD

misleading

Sure

He shouldnt give a return type when calling a function and shouldnt call the function anonymously

^

TRY THIS

INSTEAD OF WHINING AROUND THAT NOBODY IS HELPING YOU

lol try RVO

RVO?

if you are returning huge objects

are you sure that that's not completely unrelated?

return value optimization

if you are returning huge objects

.

like std string

if you are returning huge objects

the problem isn't the returning of objects

it's a fucking compilation proiblem

I know but I am giving advices

lol try RVO

and you don't "ACTIVELY" do rvo the compiler does it for you

though move semantics are better

not always

though move semantics are better

No they prevent rvo

lol OLD SCHOOL void getType(std::string& out)

No they prevent rvo

they do pretty much the same while workign on every compiler

they do pretty much the same while workign on every compiler

If a string is returned and RVO is applied there is no copy at all. When you move you need to eventually copy the sso buffer

lol you can xD

Yr

If a string is returned and RVO is applied there is no copy at all. When you move you need to eventually copy the sso buffer

Well. I can't say anything against that

xD

But for std::vector, move shoudl be fine, right?

lol

If would still prefer not to move. However the state inside std::vector is probably not as big so it might be better than moving a string

If would still prefer not to move. However the state inside std::vector is probably not as big so it might be better than moving a string

Well according to @QNeko i should prefer move over RVO, atleast in the case of ZENeural

@QNeko why?

should I rely on RVO or should I rather use move semantics when returning a vector?

move semantics are better to get certainty

we saw those three screenshots three times. Please don't post them again

Well according to @QNeko i should prefer move over RVO, atleast in the case of ZENeural

@QNeko why?

should I rely on RVO or should I rather use move semantics when returning a vector?

move semantics are better to get certainty

- A function cannot return multiple things - you are missing the return type of the last function - call your functions with this-> or just the name instead of newClass::

I see Imperial sign

- A function cannot return multiple things - you are missing the return type of the last function - call your functions with this-> or just the name instead of newClass::

this-> clutters the code, so don't use this->

#offtopic

https://t.me/joinchat/Ci0Cak-BPuxaHdcbjab4QQ

this-> clutters the code, so don't use this->

I prefer it

I prefer it

No, it clutters the code making it unreadable, imbo

@QNeko we already have certainty, so move semantics are kinda redundant, right?

@QNeko we already have certainty, so move semantics are kinda redundant, right?

You need to read the copy Ellison part carefully.. There is a distinction between RVO and NRVO

@QNeko we already have certainty, so move semantics are kinda redundant, right?

let’s agree that using ::move everywhere is just UGLY

Named RVO is when I return an object of the same part?

let’s agree that using ::move everywhere is just UGLY

let's all gladly do so

No, it clutters the code making it unreadable, imbo

It does always work, prevents ambiguity

and then, let me implement type_traits

so I made my own Neko::Move

It does always work, prevents ambiguity

well yes

Named RVO is when I return an object of the same part?

When you return something with a name

so I made my own Neko::Move

it probably works

sec

When you return something with a name

where's the difference to returning an anonymous obj?

it probably works

template <class T> typename RemoveReference<T>::Type&& Move(T&& __t) { typedef typename RemoveReference<T>::Type _Up; return static_cast<_Up&&>(__t); } ez