c-program | Some Basic C Programs

All QObjects will delete their own child objects automatically. (See docs here.) QWidgets are QObjects. So as long as you establish a parent/child relationship, you do not need to manually delete your objects. To do that, simply pass a pointer to the parent object to the constructor:

You are misinterpreting that guidance.

Your method is synchronous, and Task.Run is effectively mocking asynchronous behaviour by offloading the work to a Thread Pool thread.

In an ASP.Net context, that thread is coming from the pool that is used to serve other requests, so whilst you are unblocking the current thread and releasing it back to the pool, you are instead borrowing another thread to do the work.

This thread switching does not make any more threads available, but does introduce unnecessary overhead.

What is the solution?

Well, removing the call to Task.Run will introduce a slight performance improvement, but if your service does experience throughput issues you could persist the request to a queue to be picked up by another process, allowing your Method to return early and keep your API reponsive.

They are not defined in code. They are a property of the device, the checking is at runtime (this is easily demonstrable), and the checking is done against properties retrieved from the device in question.

You can study the deviceQuery sample code to see how it might work.

… then i will be assigned INT_MAX+1, which would overflow to an undefined value such as between 0 and INT_MAX.

No, that is not correct. That is written as if the rule were:

• If ++i overflows, then i will be given some int value, although it is not specified which one.

However, the rule is:

• If ++i overflows, the entire behavior of the program is undefined by the C standard.

That is, if ++i overflows, the C standard allows any of these things to happen:

• i stays at INT_MAX.
• i changes to INT_MIN.
• i changes to zero.
• i changes to 37.
• The processor generates a trap, and the operating system terminates your process.
• Some other variable changes value.
• Program control jumps out of the loop, as if it had ended normally.
• Anything.

Now consider this assumption used in optimization by the compiler:

… the compiler can assume that the loop will iterate exactly N+1 times…

If ++i can only set i to some int value, then the loop will not terminate, as you conclude. On the other hand, if the compiler generates code that assumes the loop will iterate exactly N+1 times, then something else will happen in the case when ++i overflows. Exactly what happens depends on the contents of the loop and what the compiler does with them. But it does not matter what: Generating this code is allowed by the C standard because whatever happens when ++i overflows is allowed by the C standard.

I don't have an easy access to a Linux where I can test it, but I think I now understand what's happening.

1. matplotlibcpp uses a static variable to hold the Python interpreter (see line 129 inside interkeeper(bool should_kill)). Like C++ static function variables, it's initialized on the first time the function is called and destructed on program's exit (reference).

2. When main finishes, libc runs cleanup routines for all the shared libraries and for your program (that's __run_exit_handlers in the stacktrace). Since your program is a C++ program, part of its exit handler is destructing all the static variables that were used. One of them is the Python interpreter. Its destructor calls Py_Finalize() which is Python's cleanup routine. Until now, everything's fine.

3. Python has a similar atexit mechanism that allows Python code from everywhere to register functions that should be called during the interpreter shutdown. Apparently, the backend matplotlib chose to use here is PyQt5. It seems to register such atexit callbacks.

4. PyQt5's callback gets called, and crashes. Notice that this is internal PyQt5 code now. Why does this crash? My "educated" guess is that Qt's library exit handler was already called in step 2, before your program's exit handler was called. This apparently causes some weird state in the library (maybe some objects were freed?) and crashes.

This leaves two interesting questions:

1. How to fix this? The solution should be to destruct ctx before your program exits, so the Python interpreter is destructed before any shared libraries terminate themselves. Static lifetimes are known for causing similar problems. If changing matplotlibcpp's interface to not use global static states is not a possible solution, I think you really have to manually call plt::detail::_interpreter::kill() at the end of your main function. You should be able to use atexit() and register a callback that kills the interpreter before the library teardown - I haven't tested it though.

2. Why did this ever work? My guess is that maybe something in PyQt5's callbacks has changed that now causes this crash, or that you use a different backend in Python 2. If no other library is destructively terminating before the program exits, this is fine.

Let's first go through with the purpose of every variable in the code.

The purpose of n,k,s is explicitly given. a[n] is for reading the numbers in array. std::vectorv(k,0) stores k sized vector of 0's, and v[i] indicates the number of variables in a[n] for which a[j]%k==i.

In the last loop, the following has done. The number of pairs that can be constructed with n elements is n*(n-1) (basic combinatorics), and if we have v[i] numbers for which the condition is satisfied and a[j]%k==i the number of pairs that can be constructed is v[i]*(v[i]-1). The loop sums up the number of pairs for every remnant i.

Since the model is related to the view then you cannot modify it directly from another thread. In this case it is better to create a signal that sends the information to the model:

threadhandler.h

In C, array bounds are not checked in any way. Therefore, you can freely try to access an element outside the size of the array. However, doing so is undefined behavior and may cause your computer to shoot demons out of your nose.

So, while working on arrays, you must yourself ensure that you only access elements in the array. You will get no error from the compiler if you do this wrong.

yes, they can be used. see:

The code: