U can try C×× Android

overload170.pdf

why " (s[n] == ' ' s[n] == '\t' s[n] == '\n')? continue : break; " is a wrong statement ?

i have used "||" operation,but it is still wrong

why " (s[n] == ' ' s[n] == '\t' s[n] == '\n')? continue : break; " is a wrong statement ?

Ok , i never know this rule

Hello guys I'm working on a ATM BANKING project and I have linked safaricom, Telcom and Airtel but there is some few implicit declarations during compile time. Someone to help

The article on why std::unordered_map in the C++ standard library is slow because of the requirements placed by the standard (the bucket interface) and why the boost alternative is better is definitely worth reading.

I think the STL unordered map is good enough, in a sense that it's safe. If you go deep enough into optimization, you will choose 3rd party one anyway to match your needs.

Where can I get some sample Malwares source codes (if possible in c++) for studying? I've searched the internet I couldn't find any.. If y'all have any ideas please help

The boost alternative is better only if you have no requirements on iterator invalidation and reference invalidation tho

bytell is probably overall better but more annoying to implement https://github.com/skarupke/flat_hash_map/blob/master/bytell_hash_map.hpp

And personally, I kinda do not like the way the boost one works, it is not even that fast and doesn't even have good guarantees

Why? How does any of boost's internal implementation change the requirements on invalidation rules?

It has quite a lot to do. The fact that it is a flatmap means that for example insertions may invalidate every single iterator. Some algorithms rely on stable iterator to work. I don't remember is deleting may also resize an under-filed map but that operates the same way. Boost implementation of flatmap also has a not very good threshold, and hence a pretty bad memory efficiency. On large maps it also is susceptible to choking on long collisions due to its open addressing design with no mitigation against that except resizing to a bigger map and praying. I don't remember if it has Robinhood hashing to limit that a bit tho

The last hash map I made mitigated that with geometric series for addressing instead of linear probing but even then it was only moderately better

The implementation that I am talking about (boost::unorderd_map) is not a flat map. It is just like the standard library ones using closed addressing and separate chaining. Instead of maintaining a link between all nodes in the map (like the standard library versions), it instead maintains a link between non empty buckets (the nodes within a bucket are linked because of separate chaining)...this is not a flat map exactly because of the non empty buckets inbetween (maybe your definition and my definition of a flat map are different). It does add some overhead in terms of the 64 bit mask for each bucket. I still don't see how erasing invalidates existing iterators or references (except for the node that was deleted). A deletion would call for just updating the links in the nodes and if the element happens to be the last element in the bucket (which can be detected by on the fly hash computation of the next element), a traversal to the first element in the next bucket and returning an iterator to the same is still amortized constant time operation.

Well if you use open addressing then your unordered map is not standard compliant because the standard requires a bucket interface for your map. This is exactly what Boost is gonna do with their flat map implementation using probing and hence I expect that to be faster

Oh I thought you meant the Boost flatmap (which is already published AFAIK)

I need to delve into the code of the mold linker

For Metacall?

I need to check how that shuffling works

Check it because you want to see if a particular section layout causes problems? I don't understand the reason behind that option unless you want to benchmark your code with randomised section layout in the executable just to ensure that the effects of the layout are taken away.

Can using pointers can fix my segmentation error?

Hey all, I have a template class template <typename... Ts> class config{} holds the map of string and variant of Ts... Now i need to do template<typename T> T& config::get() Is there any way i can check if T is in Ts...

The first answer looks like a good solution https://stackoverflow.com/questions/56720024/how-can-i-check-type-t-is-among-parameter-pack-ts

What do it mean when you write if (!file) when file is not a boolean?

file can be an object with overloaded implicit operator bool, or it can be a pointer

file can be an object with overloaded implicit operator bool, or it can be a pointer

And what means when it's a pointer

Then it will be false, if the pointer is nullptr (NULL in C), or true otherwise. It doesn't guarantee that it points to a valid object though. Depends on where you've got the pointer from

So when it's an object without overloaded operator it always means not null

If it's an object without an overloaded operator bool, then this code shouldn't compile, I think

If it's an object without an overloaded operator bool, then this code shouldn't compile, I think

It doesn't mean the object is not null

Object can't be null, a pointer to an object can be class A {}; A a; // object A* a; // pointer

Object can't be null, a pointer to an object can be class A {}; A a; // object A* a; // pointer

#include <stdio.h> //#define 1 true //#define 0 false int lower_case (char ch); int upper_case (char ch ); int to_upper_case (char ); int to_lower_case (char ); int lower_case (char ch) { if(ch>='a' && ch<='z') return 1 ; else return 0 ; } int upper_case (char ch ) // with one parameter (argument) { if(ch >='A' && ch<='Z') return 1 ; else return 0 ; } int to_lower_case (char ch) { if(upper_case(ch)) return ch + 32; // ASCII Code table else return ch; } int to_upper_case (char ch ) { // form small to big if(lower_case(ch)) return ch - 32; // ASCII Code table else return ch; } int main () { int g,f; int b,i; printf("enter a big litter to change it /n"); scanf("%d to change it to lower case %c " ,&g,to_lower_case(f)); printf("enter e small litter to change it to upper case "); scanf("%d to change it to upper case %c",&b, to_upper_case(i)); return 0; }

#include <stdio.h> //#define 1 true //#define 0 false int lower_case (char ch); int upper_case (char ch ); int to_upper_case (char ); int to_lower_case (char ); int lower_case (char ch) { if(ch>='a' && ch<='z') return 1 ; else return 0 ; } int upper_case (char ch ) // with one parameter (argument) { if(ch >='A' && ch<='Z') return 1 ; else return 0 ; } int to_lower_case (char ch) { if(upper_case(ch)) return ch + 32; // ASCII Code table else return ch; } int to_upper_case (char ch ) { // form small to big if(lower_case(ch)) return ch - 32; // ASCII Code table else return ch; } int main () { int g,f; int b,i; printf("enter a big litter to change it /n"); scanf("%d to change it to lower case %c " ,&g,to_lower_case(f)); printf("enter e small litter to change it to upper case "); scanf("%d to change it to upper case %c",&b, to_upper_case(i)); return 0; }