void* is useful in C++ when you need to treat memory as just memory. It is used in custom allocators where people need to write their own memory allocators for efficiency reasons suited to their own use cases. The part of this allocator which allocates memory doesn't know the types of objects that is going to be stored there. So they have to reference this memory using void* pointers. If you look at the standard library allocators code, you would find multiple void* references

Imo void* pointer is useless if char* exists

wouldn't arguably byte* be better for it that? since then any size is actually usable on the arithmetic of the returned pointer

wouldn't arguably byte* be better for it that? since then any size is actually usable on the arithmetic of the returned pointer

ı have three dimensional array homework

Calci needs to provide for hex and binary number input and output in addition to decimal input & output.

If I want to build nested data structures with classes. I'm getting a free Double at tcache2 error what could It be

int myhex; scanf("%i", &myhex); // input: 0x12345 printf("%x", myhex); // 0x12345

Thanks a lot ...gonna try now 🙏

Hey friends, who would like to explain to me what is the purpose of adding term "temporary materialization conversation" in cpp17? After reading the reference page of cppreference, I got more confused about it😕.

Hey friends, who would like to explain to me what is the purpose of adding term "temporary materialization conversation" in cpp17? After reading the reference page of cppreference, I got more confused about it😕.

//the text is given. write a program to cyclically shift all lines of the input text to the right by eight positions int main() { FILE* bb, * aa; int n, i, j; char str[1000], c; fopen_s(&bb, "text1.txt", "w"); fopen_s(&aa, "text.txt", "r"); printf("Vvedite kolichestvo simvolov\n"); scanf_s("%d", &n); c = fgetc(aa); i = 0; while (c != EOF) { str[i] = c; i++; c = fgetc(aa); } char t = str[0], x; for (int i = 0; i < 8; i++) { str[0] = str[i-1]; for (int j = 1; j < 8; j++) { x = str[j]; str[j] = t; t = x; } fputc(str[i], bb); } fclose(bb); fclose(aa); }

if you draw the problem you will understand how to do it

You can think of temporary materialization as a way of not creating temporaries unnecessarily. Suppose you have a chain of calls where the first call creates a temporary and that temporary is passed through the chain of calls then this temporary creation happens at the last stage and all the intermediate stages skip that temporary initialization. It is like lazy evaluation (almost). So if your function returns a non copyable or a non movable type then this feature lets you do so. Another way to think of it is guaranteed copy elision where previously copy elision was a compiler optimization.

Hi. Question : Why does std::string_view::find return std::string_view::npos if it doesn't find a substring? str.find("substring here") will return std::string_view::npos if it doesn't find "substring here" in str. Why doesn't it return boolean true or false instead? We use this as our condition: (str.find("nut") != std::string_view::npos); When it would be much simpler to use: !str.find("nut") And I don't see what reason there is for this to happen, so thought I'd ask you guys for some insight here.

Hi. Question : Why does std::string_view::find return std::string_view::npos if it doesn't find a substring? str.find("substring here") will return std::string_view::npos if it doesn't find "substring here" in str. Why doesn't it return boolean true or false instead? We use this as our condition: (str.find("nut") != std::string_view::npos); When it would be much simpler to use: !str.find("nut") And I don't see what reason there is for this to happen, so thought I'd ask you guys for some insight here.

hope it cleared that up

why would char be signed?

Perhaps this is a foolish question but is there a reason why the three catch branches here can't be coalesced? void bar() { try { foo(); } catch(foo_exception&) { baz(); } catch(std::out_of_range&) { baz(); } catch(...) { baz(); } } https://godbolt.org/z/nnP9jYc4b and I've another question which is almost certainly foolish. If I have a custom exception like foo_exception above and I know it will only ever be thrown in one place, but I disable it being thrown for e.g. in a release build, is there a way to indicate that all exception handlers for foo_exception can be omitted? I figure the answer is almost certainly no. Not that it matters for anything other than binary size but I've a niche use for something like this

Or a word appear letter by Letter E.g. Foodie => I want it to appear like f first then o then o following d following I following e

Clue : string is array of char

How do compilers keep track of RTTI when it comes to primitive types? As in I've somewhat understood how RTTI works in general with virtual but I found very little when it gets to int & co

why would char be signed?

This is because of backwards compatibility reasons with C. C doesn't have a type to represent characters. The name is a misnomer. char as was originally planned out by Kernighan and Richie was an integral type which is the smallest on that architecture. That explains why it can be both signed and unsigned like any other types. Characters are represented by their integer codes which is why the name char seemed reasonable at that time. The requirement for this type was that it be large enough to hold the basic character set of that machine and was defined to be of size 1 byte (a byte here does not necessarily mean 8 bits). Now there is this additional question of why a char is allowed to be either signed or unsigned depending on the actual implementation. This is because processors and their Instruction Set Architecture favor a specific type of char because it fits nicely onto the machine instructions in place. For example the System V ABI defines char to be a signed char. A char being signed or unsigned affects calling conventions because of the requirement that narrow types are sign or zero extended. So plain char had to be defined explicitly to map to one of those types based on the underlying architecture as compared to a plain int which is just another way of saying signed int.

when you say a byte doesnt necessarily mean 8 bits, what does that actually mean

Oki...in cpp push_back is there

i can only guess C wasn't very usable in these architectures due to the alignment

what about the opcodes though