Well, it depends how you want to use them, you probably can if it makes logical sense

#include <iostream> #include <stdlib.h> using namespace std; int main() { char choice; cout << "Enter Choice: "; cin >> choice; choice = tolower(choice); while (choice != 'e' || choice != 'o'){ cout << "Invalid, Select Again!: "; cin >> choice; choice = tolower(choice); } return 0; }

Why isn’t this working like i think it should?

#include <iostream> #include <stdlib.h> using namespace std; int main() { char choice; cout << "Enter Choice: "; cin >> choice; choice = tolower(choice); while (choice != 'e' || choice != 'o'){ cout << "Invalid, Select Again!: "; cin >> choice; choice = tolower(choice); } return 0; }

what do you think should do?

put && instead of ||

put && instead of ||

Hello, can anyone help me set up c++20 for gcc. I have version 12.1 on manjaro but even after enabling the flags -std=c++20 and -fmodules-ts, I still cannot compiled modules (i.e. import <iostream>;) for my code.

Modules are still a work in progress, while they are implemented in the compiler, no build system makes use of them yet

Modules are still a work in progress, while they are implemented in the compiler, no build system makes use of them yet

Hello, can anyone help me set up c++20 for gcc. I have version 12.1 on manjaro but even after enabling the flags -std=c++20 and -fmodules-ts, I still cannot compiled modules (i.e. import <iostream>;) for my code.

How about clang? Having the version 13.0.1 installed but I am still unable to compile my code after enabling the -std=c++20 flag.

Module support for standard libraries is not a partof the C++20 standard. They are slated in for C++23. But Microsoft Visual Studio already supports this.

OK. Quite unfortunate because I just started learning c++ from the book beginning c++ and the author seems pretty sure that modules are available for most compilers. I was using visual studio but it is just resource intensive and time wasting so I thought that maybe manjaro being a rolling release distro should have the latest version of gcc which should have considerable support for c++20.

Beginning C++ by Ivor Horton????

Do you know any other alternative compiler with c++modules support?

Nopes. Except for Microsoft, no other compiler supports standard library imports

Yes, beginning c++20 to be specific

Ivor Horton is a horrible author (atleast his C++ books are) and his books are not standard compliant. He is known to encourage bad programming practices

#include <stdio.h> int main() { for(printf("FLOWER");printf("YELLOW ");printf("FRUITS")) { break; } return 0; } The outuput of program is FLOWERYELLOW Can anyone explain this?I thought this will throw an error.

#include <stdio.h> int main() { for(printf("FLOWER");printf("YELLOW ");printf("FRUITS")) { break; } return 0; } The outuput of program is FLOWERYELLOW Can anyone explain this?I thought this will throw an error.

we run the inicialization code which outputs FLOWER; we run the condition code which outputs YELLOW and returns 0 which is false so we don't execute anything further in the loop

return value doesn’t matter in this case

we run the inicialization code which outputs FLOWER; we run the condition code which outputs YELLOW and returns 0 which is false so we don't execute anything further in the loop

How to show an Arabic word or a Japanese word in the OUTPUT

do a research about returning utf-8 outputs.

do a research about returning utf-8 outputs.

And can I use the same thing in a another languages!? Right?!

And can I use the same thing in a another languages!? Right?!

Hi everyone! Me and my friend have two programs written in C language (let’s call them A and B) that are executing exactly same tasks. In particular: they do thread oriented job. But there’s one problem: program A is working significantly slower when compiled with -fsanitize=thread and crushes almost immediately, whilst B works as if nothing changed. Question: - Can someone suggest interface/utility that analyze performance (and can find potential bottlenecks) in a C program?

does the second approach take less time than the first? for (int i = 0; i < string1.length(); i++) // int j = string1.length(); for (int i = 0; i < j; i++) I mean to ask, is the string.length() cached during first iteration?

No it is not cached. But methods like size(), length() and end() are required by the standard to be very efficient and constant time. So practically there is no difference. You compute size or length in the loop everytime if the loop body does something that might change the size of the string. So which option you choose depends on your loop body. This is also precisely the reason why you should not change the container you are iterating on while using the range for loop. That is because the range for loop computes the end() iterator only once and any subsequent changes to the container may invalidate the end iterator and thus result in UB.

No it is not cached. But methods like size(), length() and end() are required by the standard to be very efficient and constant time. So practically there is no difference. You compute size or length in the loop everytime if the loop body does something that might change the size of the string. So which option you choose depends on your loop body. This is also precisely the reason why you should not change the container you are iterating on while using the range for loop. That is because the range for loop computes the end() iterator only once and any subsequent changes to the container may invalidate the end iterator and thus result in UB.

>> You compute size or length in the loop everytime if the loop body does something that might change the size of the string. Compilers should cache the length in const context, but it doesnt happen

Because the standard recommends against this optimization. This shouldn't prevent an implementation from using it but generally they don't. It is also the reason why the standard places strict requirements on the efficiency of such methods. Also it is not just non const methods that the compiler has to worry about. Even calls to external methods need to be analysed. This places a much bigger burden on compilers for a relatively very small performance gain.

calls to external methods can be not analyzed, because u cant get nonconst ref from const ref(without UB, i mean)

const std::string& ss = "123fas"; while(i < ss.length()) { std::printf("%d", ss.at(i)); ++i; } in the compiled code, there is a check of the string size in each iteration, the string size is obtained each time from memory

in this case it can cache, but it isnt

in this case it can cache, but it isnt

in my case, compiler knows, that const ref is temp object

There are limits to what a compiler can and cannot do. Something that is very obvious to you may not be as simple for a compiler implementor. That is precisely why the standard explicitly calls this situation out and expects the implementations to instead focus on making these methods more efficient so that there is no performance impact when their results are not cached

I think compilers doesnt have good lifetime analysis nowadays. Maybe replacement of Clang AST in clang to high level intermediate language will solve this problem(in PoC there is special way to handle lifetimes)

Yes and it is not just a proposal. An implementation is also available. But there are limits to what it can do. Just plain lifetime analysis without a borrow checker can bring in only a few improvements. But C++ is not trying to emulate Rust. The lifetime analysis checks can at best handle some dangling references and pointers (using smart pointers alleviates this problem). They can't handle concurrency issues and more complicated scenarios. For example : The proposed lifetime analysis won't help with issues like in the code below: #include <iostream> #include <vector> int main() { std::vector<int> xs = { 10, 20, 30 }; auto it = xs.cbegin(); xs.push_back(40); std::cout << *it; // possible use-after-free: dereferencing an iterator that was invalidated }

deep analyzing of high level IR could help, but there will be a lot false positive cases, i think

No it won't be of much help outside of a couple of cases.

btw the Rust compiler is still not fully disclosed: the Rust frontend has a lot of information about types, lifetime, and other little things that give a huge optimization potential. Therefore, my expectations about optimizing strings in C++, which the Rust compiler could do, remain in wet dreams(C++ is much more difficult to analyze than Rust)

printf your sum(number) function

how do i sort a structure in alphabetical order using pointers in C

eg i have name of workers and need to sort them alphabaticaly by using pointer

i will check it out