Unitial | 🖥 My rc / configs / dotfiles | Command Line Interface library

You need to add /lib to the eager load paths as well:

C Class gets initialized before B Class which is expected.

No, it's not expected, the order of evaluation of function arguments is unspecified.

But even if that's the case as in your example output, you've created new C class object, and now you are trying to create B class object and during that, you are trying to access A::instance->c which is not set yet.

You set c for class A object in the start function, but you are still evaluating its parameters during this calls and didn't reach the actual body of the function.

Thus, the c in the class A is the default 0 as you set by C* c{ 0 };.

f_sym[0] was never set because the counter was incremented (++counter) before entering the if statement. When later accessed f_sym[0] was indeed uninitialized. Fixing counter solved all problems. Just in case anyone ever reads this question.

According to the site, the task is to convert the hex to base64.

Your encoding, seems to be working correctly as the library base64 outputs the same as your result when running it directly over the hex value

Currently the structs in the array are uninitialized

No, they are default-initialized.

While this means that the struct variables are also uninitialized

The effect on the members depends on the definition of RandomStruct. Depending on that definition, default-initialization of RandomStruct may have the effect of default-initialization of some or all of the non-static data members of RandomStruct. It may have the effect eventually of default-initializing a variable of non-class type, as a member of RandomStruct, or a member of a member, etc. That variable of non-class type will have an indeterminate value.

Like if I, for example, set all the variables from an unitialized struct to the desired value, and then use functions of this struct, or if I use functions of the struct that don't use uninitialized variables before I set them

If all members are initialized to determinate values before being used, everything is OK. Member function calls that don't "observe" the indeterminate values are OK.

Am I correct in thinking that only the variables will be uninitialized and that what the array does is just assign random memory to each of the struct's variables?

That's not quite true. That would imply that observing the indeterminate values is OK but their value is just unknown. It is not. But so long as you don't observe the values, this is a valid intuition.

It is OK to leave them indeterminate so long as they are not observed. But, it is undefined behavior to "observe" the indeterminate value by producing it in any evaluation, except in very limited, enumerated conditions.

This means that a correct program is not allowed to observe the value, but the compiler is also not required to diagnose it. However, the compiler can assume it is never done (because a correct program cannot do it) and C++ places no requirements on an invalid program.

The reference documentation for strtok_s shows that the above code is perfectly valid assuming that string is not a NULL pointer. Whether "an address of an uninitialized variable is a compile-time constant" is completely irrelevant and doesn't have anything to do with the diagnostic. The compiler thinks you are using uninitialized memory.

However the 4th parameter to strtok_s, as per documentation, needs to have the pointed-to pointer initialized (by an earlier call to strtok_s) only if the first parameter is NULL.

The compiler is being rather picky, it seems. It looks like the compiler cannot prove to itself that string will never be NULL here, so it's complaining about this.

But, if you never call strtok_s here with a NULL pointer here then there's nothing wrong with this.

We can use accumulate from purrr to get the output of previous row as an input to current row.

once I declared char array[ 10 ]; does the last subscript contains '\0' ?

No. It's uninitialized. It has garbage values in every element from whatever code used the same piece of memory last.

When you use a static library that has dependencies on other libraries then the compiler is going to complain if it can not find those other libraries.

The difference between Microsoft Visual Studio 6.x and Visual Studio 2019 is immense. As I've ported old code, both C and C++, from 6.x to VS 2015 I have had to make a number of source code changes to allow compiles to work due to the improvements of Microsoft in its adherence to the standards as well as supporting new versions of the standards, some of which deprecate previously supported constructs.

See this post about compatibility between versions, Library ABI compatibility between versions of Visual Studio See as well:

Binary compatibility between VS2017 and VS2015

ABI-Compatibility of visual studio c-libraries

And this blog posting from Microsoft about the release of Visual Studio 2019 dated 2019 says:

Visual Studio 2019 version 16.0 is now available and is binary compatible with VS 2015/2017. In this first release of VS 2019, we’ve implemented more compiler and library features from the C++20 Working Paper, implemented more overloads (C++17’s “final boss”), and fixed many correctness, performance, and throughput issues. Here’s a list of the C++17/20 compiler/library feature work and the library fixes. (As usual, many compiler bugs were also fixed, but they aren’t listed here; compiler fixes tend to be specific to certain arcane code patterns. We recently blogged about compiler optimization and build throughput improvements in VS 2019, and we maintain a documentation page about compiler conformance improvements in VS 2019.)

I don't see any other recourse than to work with the source to make it compatible with Visual Studio 2019. If you look, you may find that your level of expertise with C is sufficient for to implement some of the suggestions below.

The best course of action would seem to be to make the necessary source code changes to the library so that it will compile correctly under Visual Studio 2019.

The best course of action is to review the source code in each place where the uninitialized pointer error is being found and correct the source code so that the error is no longer generated. The programmers who previously worked in those areas of code obviously left out a potential flow of control probably due to their expectation that the missing code would never be executed based on the assumptions of how the function would be used. Most likely any such functions are complex and may need to be refactored.

Most often I have seen this type of missing flow being due to a switch statement missing a default: to capture the event of the switch variable not being one of the specified case values. It may also be due to an if statement that is a series of else if without a final else to capture any other possible condition. Or it may also be due to a loop which has a break statement before the pointer variable is initialized or which uses a continue statement to skip where the variable is initialized.

In most cases these issues are due to functions with low cohesion and/or are overly complex and large with maintenance actions over time introducing these kinds of problems.

A less desirable practice for the error of a potentially uninitialized pointer is to just initialize with some appropriate value. You can jump to where the error is, click on the variable and go to where it is defined, and then set it to an appropriate value. In most cases a value of NULL for pointers is safest because if it stays NULL and is used without being modified to a correct value, your application should crash letting you know there is a problem.

By initializing to NULL you are assuming the previous programmers knew what they were doing and the possible flow(s) detected by the compiler that would leave the variable unchanged to a proper value will never happen due to the logic.

And should the uninitialized pointer flow happen, you will find out when the application crashes. Unfortunately tracing back to the origin of the crash may be difficult.

You can use assert and other tests within the code to create a break point should you be debugging or to generate an exception, if it is C++, which may be more informative than just crashing. So adding such a test just before the line of source code generating the error, checking for NULL in the test before using the pointer may be helpful.

Or if the function has a status code indicating if it worked or not and any errors along with some way of returning an error status then the most efficient thing would be to use that error reporting at the pointer where the potentially uninitialized pointer error is being generated should the sanity check fail.

However if you can discern a safe default value, you may want to use that instead. Discerning a safe value will require reviewing the source code to determine what the safe default value should be. Sometimes such a safe value can be the address of a variable of the appropriate type initialized to zero.

Warning: if the address in the pointer is being returned, do not use the address of a variable local to the function. When the function returns that address will no longer be valid leading to Undefined Behavior.

Warning 2: if the address in the pointer is expected to have been allocated using malloc() or new or similar memory allocator then you must use the same mechanism so that when some code decides to deallocate the memory using free() or delete then it will work.

This review will require reading the source code of the function where the uninitialized pointer is being used if the value of the pointer is localized to the function itself. If the pointer is returned by the function, the value exported by the function to a user of the function, then you will also need to review the source code where the function is used in order to determine an appropriate default value.

So what I suggest you do is that every place where you do the initialization, you add a unique identifying comment (something along the lines of "Inhahe fix uninitialized pointer error 06/10/2020") to the line so that you can then do a search to find these at a later time and then go back into the problematic code and actually fix the compiler error by refactoring or changing the code to eliminate the possible uninitialized pointer error.

And before you do anything get the source under version control of some kind.