No, divisions are slower because they are done by loop

Internally?!!!

Aghh that sucks

how do you get a modulo by shifting? @ollirz @Drazzy ?

No, divisions are slower because they are done by loop

No shift, modulo use and for Power of two

wasnt aware of that 🤔

we are talking about the modulo part of the division 😉

mov eax, DWORD PTR [rsp+12] .loc 1 8 1 add rsp, 24 .cfi_def_cfa_offset 8 .loc 1 7 16 mov edx, eax shr edx, 31 add eax, edx and eax, 1 sub eax, edx Oh

what a stupid question

I overloaded the >> operator, and it seems to call the overloaded version every time I use >>. Is there a way I can indicate when I want to use the overloaded version?

operator >> participates in overload resolution (as regular functions do)

I'm trying to do (stringstream) >> (size_t), but I found out it's using my overloaded operator (ap_uint) >> (ap_uint) where ap_uint is a class.

it takes 3 years, including the time it takes for the insight that C++ is kinda shit

Please, how do I sort a struct that is an array with different data type members? For example: the struct is a product with an ID, NAME, PRICE. And I want to sort on the name. And please, one more thing, how do I print to the console like how more or less command works on Linux? i.e. part of the output at a time and print the rest as the user presses a key.

I assume you mean "a array of structs". You can use either qsort and provide a comparison functions (in C) or use std::sort and a custom comparator (in C++). See: https://en.cppreference.com/w/c/algorithm/qsort https://en.cppreference.com/w/cpp/algorithm/sort

Rand vs srand vs <random> for secure randomizes

Why we just not prevent the error of "out of the index bound" by using the % arithmetic operator Like if we have an array of size 10 And the user asked for the 15th element We just write arr[15%10]

It's like actually cleaning your room, instead of just shoving everything visible under the carpet

That makes 0 sense. Let's look for example at an off-by-one error. So you have an array of size 10, but some because of some bug it turned out that you tried reading 11th element. So if you don't do anything you'll either get some completely unrelated value or segfault. If you do your stupid modulo thing you'll be delivering the 1st element like nothing wrong happened. How's that going to help?

Okay If that so Why we didn't say the same thing on primitive types?! char c = 256: It will be truncated to 0

What do you want to happen?

Like a program that is asking for input of the ascii code and then provide the corresponding char

Ub ಠ ل͟ ಠ

It is

Like what do you want c to be?

The same thing What do I want from an array that is 10 elements to be?!

There's no way to store 256 in a char

There's no way to store 256 in a char

Like you want it to automatically find you a bigger type to store it?

No

What happens in the primitive types must happen in the array

No

Why?!

Because it's worse than just accessing the wrong element

What happens in the primitive types must happen in the array

who says the pointer type doesn't wrap around?

What?!!

who says the pointer type doesn't wrap around?

Like ar[11] == ar[0]?

What?!!

If someone afraid of hiding in the carpet He can also use exceptions, right?!

int foo() { int ar[] = { 1 }; return ar[static_cast<uintptr_t >(-1) + 1]; } the size of the address does not depend on the array size but on the pointer size. And uintptr_t wraps around as well (as every unsigned integral type)

yes, that's why std::vector<T>::at exists, it does a bounds check and throws exceptions

What is unintptr_t?!

unsigned integer type capable of holding a pointer (the type is optional though, on some platforms pointer are bigger than integral types)

So Do you say that casting is more efficient than just using the module?!

no. I just all integral types behave the same in regard to wrapping

Hiii