c-standard | Clone of http : //nsz.repo.hu/git/ ? pc-standard | Document Editor library

You don’t need anything other than mp4 for up to date browsers, but if you want to support older open source browsers as well you can add a ogg or webm file

Why the creators of C standard have made quiet NaN not always quiet?

As far as I can determine, the C standard does not anywhere specify, directly or indirectly, that there is a circumstance where usage of a quiet NaN must cause a FP exception to be raised. Thus, the standard committee has not made quiet NaN fail to always be quiet.

The committee also has not required that usage of quiet NaNs must never cause a FP exception to be raised, of course, and that allows for (but does not require) cases wherein quiet NaNs do cause FP exceptions. But that does not contradict the previous paragraph.

The standard is designed to support implementation on a wide variety of hardware, and to that end, many details of FP behavior are left unspecified. This allows C to be implemented naturally, in terms of the native FP behavior of the host machine (where that exists). Among other things, C does not specify FP representation, so what the standard means when it talks about NaNs, quiet or otherwise, is more general than what IEEE 754 means by the same terms.

It's likely because n is a variable, the compiler doesn't seem to be verifying it, as it doesn't know its value it doesn't issue a warning, if you turn it into a constant i.e const int n = 64;, the warning is issued.

https://godbolt.org/z/4s5jz6

As for the results, undefined behavior is what it is, for the sake of curiosity you can analyze a particular case and try to figure out what the compiler did, but the results can't be reasoned with because there is no correct result.

Even the warnings are optional, gcc is nice enough to to warn you when a constant or constant literal is used but it didn't have to.

Suggested, taught in schools as a "best practice", but no, not enforced by the compiler - not to the extent that a declaration must appear before any executable statement in a procedure scope, no.

VB6/VBA code can declare locals anywhere within a procedure scope (the smallest possible scope in VB6/VBA); the catch is that Dim (and Const, also legal in local scope) statements aren't executable (you can't break on them), and I would guess the reason it was so warmly recommended to "just put them all at the top" is that local declarations must appear before the first use of a variable: having a block of declarations therefore ensures all local declarations are legal.

Caveat: ReDim statements are executable, and they act as a Dim declaration. It is perfectly legal to have ReDim someArray(1 To maxValue) even if someArray wasn't previously declared, even with Option Explicit specified.

But having a block of declarations at the top of a procedure isn't a modern best practice...

[...] are crammed together at the top of methods, generally out-of-sight from where the variable is used.

...and IMO this is exactly why.

VB.NET changed the rules of scoping a bit (you can now have an inner scope inside a procedure), but what it really did was to introduce a knowledge gap tight enough that VB6 devs wouldn't be too intimidated, but wide enough that the new language & framework could boast a new set of best practices - and the onboarding devs would just embrace them. New language, new ways: out with Hungarian Notation and walls of declarations at the top of procedure scopes - and just like that, the new recommendation was to declare variables where & as you need them, and to never prefix any identifier with a type abbreviation.

But much of the VBA crowd weren't devs, and didn't hop onto the .NET bandwagon, and essentially missed the memo with the updated best practices that could effectively apply in VBA/VB6 even though they were pushed for VB.NET. VBA/VB6 isn't necessarily stuck in 1997 though; the Rubberduck project (open-source, I manage it) aims to modernize the VBE, its tooling (static code analysis, refactorings, unit testing, etc.), and the coding practices around it.

What I see in your question is you trying to create xml formatted content, and trying to deserialize it just to count the content, that would be fine if you need to collect data, but if the intention is only to count words tagged in between body of documents it is much faster to just parse it and count it on the fly.

My strategy is to take substring of content that starts with and take the substring that ends with and count it by splitting it.

Here is the solution:

All information related to automated backups and the storage used by Azure SQL is not available to customers as it is managed by Azure behind the scenes, and that is part of the benefits of using platform as a service.

For example, when you go to the restore a database on the portal you can see the options that you have and you can only select to which point in time you want to restore. This is part of the idea of getting a platform as a service (PaaS)... it is managed for you. You only need to choose the point in time and the Azure service should map it to the internal file(s) behind the scene. As those files are managed by Azure you cannot see them or see their attributes, that type of information is available on IaaS, not on PaaS or SaaS.

If you want more control about backup files on Azure SQL, choose to backup databases to storage accounts using export feature or using SqlPackage utility or using Azure Automation.

You can detect this by running it with an empty input file and different -std arguments and checking if it compiles. That's how CMake does it.

I think I found the solution. It is described in appendix of FIPS 202 B.1 (starting on page 26). A hint on this topic is given on page 25:

The convention for interpreting hexadecimal strings as bit strings for the inputs and outputs of the SHA-3 examples is different from the convention for other functions on the examples page. The conversion functions between hexadecimal strings and SHA-3 bit strings are specified in Sec. B.1. For byte-aligned messages, the hexadecimal forms of the padding for the SHA-3 functions are described in Sec. B.2.

There is a good explanation on how to circumvent this issue on cryptologie.net.

why C++ decided to disallow people to implement std::to_string for their own type

This is where ADL is useful. We already have the example of how to correctly do this with std::swap, which is successfully done in many codebases already: