Comments by Rick York (Top 200 by date)

No, I know of no developers who use MFC for new projects but that is of absolutely no concern to me. I have MY work to do and they don't help with it. Yes, I DO use MFC for all new projects I am given and all my projects at home. Incidentally you can see some shots from those in my profile. My avatar image comes from one of them. I am very, very productive using MFC so that is what I use and I can think of only one reason not to: I find microsoft's operating systems to be nauseatingly disgusting. The nonsense they have been adding to them lately turns my stomach. I am about ready to retire and I will move myself to Linux when that happens and I will examine my alternatives then.

I have no idea why you think MFC "won't allow the use of standard C++ data structure." I use plain C structures and STL classes with MFC all the time. I always avoid using MFC's collections and use STL classes instead. There are a few methods that use CStrings but that's only one I have to deal with and it is rare.

What does "holding down the window" mean?

I think the reason for his problem is in my "BTW" comment. Every time I use a wait cursor suspension of the message loop isn't a problem because changing the cursor forces it to be redrawn.

This is definitely the way to go however, I don't see MFC in the tags for the question so it might not be an option for this person.

You should mark your question as solved so it does not appear on the unsolved list.

That is a rather curious design if that is what you have to do. I have written a lot of programs that do rendering both 2D (usually GDI+) and 3D (OpenGL, see my profile) and they are almost always double buffered and I have never had a persistent memory DC. It is always drawn to, written to the device, and then automatically deleted. That means this topic has never come up for me because I always do printing from the device. Why do you need to print from the memory context? Also - the printer and device (nearly) always have different resolutions so why does that make a difference in this case?

Why in the wide world of sports did this question from August of 2022 need to be updated???

I have written code that does insertion into an array before and I found there two key things. First is pre-allocate more memory than will ever be actually needed for the array. Second is the function memmove is very handy for moving the array elements down to make room for the new item(s). In my case it was an array of characters but the principles are the same.

I have fought this battle for years. That is, how can I have event logging and trace messages and display them at the same time? We could never come up with a high performance method with files so we resorted to using a shared memory buffer and then writing a separate extraction process that displayed the messages and/or wrote them to files. My current implementation is VERY high performance with an average message logging time of 750 nanoseconds. The best performance I have seen writing to a console is more than ten times slower and that's only after the text buffer has been filled once. Until then, it's another ten times slower and it takes 9000 events to fill the default buffer. Writing to a file is slower than that.

That's my recommendation: implement a ring buffer in shared memory and a separate process (I call a slurper) to display and archive the data. The buffer I use has 32K slots, 256 bytes each, and occupies 8MB of memory. One nice thing about this is multiple processes can utilize the same buffer and, if you do it right, you can have multiple buffer instances.

I have used the unordered_map several times and I consider it to be very, very high performance. I have a program that puts 12K file names in a map where the first few dozen characters were all the same and it read them all from the directory in less than twenty milliseconds. I can't think of a reason for needing better performance than that. I really couldn't care less how much of the CPU it uses to do that and I can't think of a good reason why that should matter.

That works until someone enters 100 characters and then they have an unterminated string. This is why I prefer the #define (or a const int) and the declaration to be char a[MAX_BUFFER+1]={0}; The +1 leaves room for the null character and the rest of the code doesn't change. Also, initializing it adds the null every time, including when building in release mode. If sizeof is used then a -1 is needed to be safe.

I wrote the code the way it is specifically so I could avoid setting the null character. Initializing the buffer that way means you do not have to because it's taken care of. Using the strncpy function with the appropriate size insures that the terminating null character is not touched. THAT is why the type is defined with the +1 - it simplifies the code.

I used the code presented here successfully : https://www.codeproject.com/Articles/34508/WinAES-A-C-AES-Class

I probably can but this isn't my homework.

Yes, I know. I read the documentation on the class. https://learn.microsoft.com/en-us/cpp/atl-mfc-shared/reference/cimage-class?view=msvc-170

Here is documentation on CBrush : https://learn.microsoft.com/en-us/cpp/mfc/reference/cbrush-class?view=msvc-170

Have you tried the FromHandle method?

That is one of several reasons I avoid using DLLs unless I absolutely have to such as with hooks.

Incidentally, this seems like an interesting problem so I decided to give it a try. I found the best initial guesses to start with are -10000 and 0 and let the search begin from there.

I noted that in my solution also, which I started writing before I saw your comment.

Nothing different.

That sounds about right to me. +5.

I rename the .sln, .vcxproj, and .filters files and then edit them to have the project name I want. This takes about one or two minutes. In fact, it is so quick that I haven't bothered to write a little to do it. I also change the GUID so that settings are saved correctly. There will be issues if they do not match.

I don't think that is very likely. I would guess that you have an OnEraseBkgnd message handler that isn't doing what it should.

I do this kind of thing quite often. So often that I wrote a little function do this. It is called HideDisable and it disables the window and hides it. I don't have it invalidate anything because it is almost always called in OnInitDialog and that causes the entire dialog to be redrawn when it completes. In code where controls are dynamically hidden the entire dialog is invalidated so everything is redrawn.

Yes, and the embedded tag was used here so it is likely that it doesn't have a 1MB stack like a desktop program would so problems would happen much quicker.

It is a potential hazard but I don't think it is anything to worry about because very little is pushed on the stack. However, this is one instance of pointless recursion. It makes little sense for that code to be recursive instead of just using a while loop.

I don't see how the program is allocating memory more than once - right after the file is opened.

Incidentally, I would check for the allocation and open errors separately so you know exactly which one happened.

Upon further review, I think you are right. I will revise my answer.

You really need to edit your post and re-paste your code. Also, be sure to select all and then click untabify because I think the tabs are what fouled it up. I wrote re-paste because there are several things missing that would prohibit what you have pasted from even compiling. For example, the function sumfunc does not have an opening brace. Also, in the if statement about tryagain the word addition appears with a semicolon. That is a meaningless statement so either something is missing or it is just an error.

The question was far from clear but if the controls for the dialog(s) are in the resource file then one does not need to create them. The DDX_CONTROL statement will map the object to the resource so calling create is unnecessary.

The most common problem I have had with socket interfaces is disconnections from inactivity. I always have either a periodic status update message or I put a "PING" command in my interfaces now just to keep the connection alive and it simplifies things quite a bit. I still have re-connection logic because it happens but much more rarely now.

I use MFC and when I call its AfxRegisterWndClass function and provide a brush from GetStockObject it works correctly. Are you using MFC? In another program, this non-MFC one : https://www.codeproject.com/Articles/2151/Windows-Fortune-Application, I have it do nothing in the WM_ERASEBKGND handler and the background is drawn in the WM_PAINT handler.

I think you are just not doing things quite right because these tactics can work. I can only guess because there was no code posted.

I really don't know but I consider fgets to be a better option to acquire text input. Once you have a line of text you can then use sscanf to extract various data from it if you want to. The format options are the same as scanf.

In my opinion, this is not an effective simulation of that. I think the errant counts occur because more than one thread is iterating. I think a better simulation would be to have some threads searching and another thread that periodically removes one entry and then adds another (at a quick interval) and run them concurrently. That will give the access control of the map a good test.

As Richard mentioned, it is important to test a lot. To facilitate that, I recommend that you put your input into files and redirect your program's input to read that file. That way you only have to enter the data once and your testing will go much, much faster.

"The following code is perfectly legal:"

No, it is NOT legal. it will not compile because it must be const.

As it turns out, that was the culprit. At least one of them. The main issue was OP's override was not const. I revised my statement because I verified for myself that it can be done.

"The code below will only cause your classes to incure unnneccessary overhead, so dont't use it:"

That is false. That code will NOT incur any additional overhead and will, in fact, be faster than the STL implementation. It has has half the number of increment operations, half the number of comparisons, and one less function call. The fact is, the speed difference will be very small and probably unnoticeable except for with a very large collection on a slower machine BUT there will no additional overhead.

Thanks. Actually I just happened to notice the last code snippet had the issue.

You have to compare item by item. I will amend the solution to illustrate this.

I recommend that you figure out how to read data from files. I would make three files : Library.txt, Patrons.txt, and Transactions.txt and each of those would have a list of entries for you to inject into your program. This will make your testing iterations much more flexible and thorough.

I assume you are asking about this : net.mNeurons.back()->unaryExpr(ptr_fun(unary))
You have not provide nearly enough information for us to guess. The biggest questions are what is NeuralNetwork and what are the prototypes of unaryExpr and ptr_fun?
How do you expect us to know?

I work on a fairly big application that uses a mix of doubles and floats. The reason for this is a large part of the code is written to work on both CPUs and GPUs (using CUDA) and floats are considerably faster than doubles on the GPU. I use doubles most of the time elsewhere and always in my home projects, as seen in my profile. They are all graphics-oriented and I would see lots of artifacts when I use floats.

If all of your code was present we could build ourselves and see what's going on. As it is, we can only guess.

The code you posted is not complete. It lacks the functions hozzafuz and osszkerdes and the type Adatok is not included either. It also lacks beolvas_fajlbol.

If you have a decent connection you can download and use Visual Studio at no cost. You could use it and its debugger to make your program work and then move it back to CodeBlocks. That should work without issue.

It appears we wrote essentially the same thing at the same time and I don't know why you didn't get an up-vote so here you go.

unique_ptr is very, very handy. I try to use it whenever possible. One primitive way to use it is just to hold the pointer and eliminate the need for explicit deletion. I sometimes do this because it greatly simplifies code. You can have multiple return points and you don't have to remember to delete anything before each of them. I've been wrapping lots of resources in container classes just to have this automatic deletion capability.

What I meant earlier is you can construct an object in the usual way and then call the reset method of unique_ptr to save the pointer and that makes deleting the object automatic.

What is a tip of a cbutton?

Here's the prototype for it : BOOL WINAPI ChooseFont( _Inout_ PCHOOSEFONT pcf ); The question is what does your CHOOSEFONT structure look like? That determines how it works.

That is NOT my code. What I posted does not have a main function.

No and STOP GIVING ME ORDERS!!! The default value is set for the member variable and that is adequate. A destructor would be useful though. Try being less rude in the future.

Show us the include statements you are using. I think that is where the problem is. I use just the default include paths plus my own libraries and there are no problems. I include gdiplus.h in a precompiled header.

A void pointer is a pointer to data of an unknown type. A double pointer is something different. That is a pointer to another pointer. In a 64-bit program a pointer is eight bytes but in a 32-bit program it is four bytes long.

Malloc doesn't exactly "have the address of a pointer." It obtains a pointer from the heap memory manager and returns that pointer to the caller. There are (at least) two basic types of memory in a program - the heap and the stack. The stack grows and shrinks automatically as functions are called and return. Non-static variables that are local to a function live on the stack. When a function is called the stack grows to accommodate those local variables along with the address to return back to. When the function returns the stack shrinks back to where it was and program execution continues at the return address that was just popped off the stack. The heap is a different piece of memory that is used when memory is allocated by calls to malloc and calloc.

I think this sentence : "Pointer arithmetic uses the size of the pointer." is incorrect. Pointer arithmetic uses the size of the data the pointer points to. If you a char * and you increment it the difference will be 1 - the size of a char. It will NOT be 4 which is the size of a pointer in the 32-bit world. Similarly, with a double * when it is incremented the difference will be 8 - the size of a double.

What does "valid" mean in this context? That is not clear.

If these solutions solved your problems you should accept them so your question is consider answered. Upvotes are also nice. :)

You have a few syntax errors there. Please see my revisions. They have been verified to work correctly.

Yes, you are right. It didn't used to be this way so I learned a long time ago not to do it. Regardless, you found the problem so have an up-vote from me.

You are on the right course. Make sure UNICODE and _UNICODE are undefined and the program uses the MBCS. That should be enough to make it happen. You can always use wide characters where they are required even with those options. I think that is what needs to happen here. With those options, LoadLibrary will actually be calling the LoadLibraryA function. Since WinUI3 wants to use the wide character prefix for that library's name you can call LoadLibraryW and it should work just fine with the rest of your code in MBCS mode.

You are welcome.

Except for loop indexes, you should avoid using single letters for variable names. They are detrimental to readability.

Your code is not trying to open thirdDlg. It is calling ShowWindow on the dialog after setting its position. That means it has to be open first. Did the trace message say the thirdDlg was valid or not? Also - make sure it is being moved to a valid position. Actually I would try it first by not moving it just to rule out that aspect of things.

It is on the border line but, for the most part, yes.

Yes, good point. In my testing I made the triangle struct use doubles which made the casts unnecessary and I forgot to include that in the post.

What I don't understand is why you have to load the DLL and obtain the function address. You can build a static link library and make that unnecessary. Normally when a DLL is built a .LIB file is generated so, again, you don't have load the DLL at run-time. In other words, if you link to the library correctly you will not have to load it at run-time.

Have you tried searching for animation? https://www.codeproject.com/search.aspx?q=animation&x=7&y=1&sbo=kw

FWIW, I learned C programming with a very simple, basic book and I worked through all the examples and tweaked a few that I was curious about. Once I had the basics (mostly) then I started on what is still one of my primary interests : computer graphics. I did all kinds of graphically-oriented things and learned a LOT. One of the first things I did was rotating wireframe objects then I moved onto fractals and spirograph shapes. I am not advocating this approach but my point is you will likely learn the most if you pursue something that is of interest to you. The key will be figuring out what that is.

Keep in mind that with TCP/IP there really ISN'T a limit on number of bytes per message. There is a limit on the number of bytes in a normally-sized pack of about 1500 bytes but a TCP/IP message larger than that will be split between multiple packets and the protocol will insure that they are all received in order. Many NICs and switches support what are called "jumbo frames" which can range between 5 and 15KB. All equipment between sender and receiver must support jumbo frames for you to use them. My point is I wouldn't worry too much about the frame size limit unless you are also writing the protocol handling code and have to deal directly with that. A robust socket handling library should be able handle that kind of thing.

If you work with other people then that is not the way to do things. If you worked with me I would be very, very annoyed. I work with dozens and dozens of projects and I never, ever change VC's include or library directories. Those are user and installation-specific settings and should NOT be changed. Setting the include and library directories is something that should be changed in your projects' settings. In order to work well with other users' you should always use relative paths no two users install things the same way and in the same places.

Debugging it is the easiest and fastest way to find out what is wrong with your code.

It would be easier to help you if you provide some code that tests these functions.

I suspect the issue has to do with the <=-1 comparison with an unsigned value. I haven't looked at the assembly code generated to verify though. Regardless, I think this is a compiler bug.

One thing I still find odd about this : I did not have a problem with the [] operators in the iterator class so they do not call the IsValid method.

I agree. I try to avoid all MFC collections and CString. I can't always but in the vast majority of cases I can.

As Mr. Pallini mentioned, std::vector would be a better option. I have used MFC for a long, long time and I still do but I never use the MFC collections or strings. I always use STL classes like vector and string. In my opinion, MFC is good for handling windows, dialogs, and controls but I do not like their collections at all.

Where ever you want to update the edit controls. Usually it's done in OnInitDialog but if those values are changing constantly then you can also do it in OnTimer or when you get a notification that they have changed. That's the point though - do it when ever you need to and where ever it has to be done.

That code looks appropriate to me.

Were you given a target processor for this assembly language program?

Of what significance is the value 20? You have five integer arrays of that size. It is bad practice to use hard-coded values like that.

Was it actually necessary to resurrect a nearly six-year-old thread?

You would have to get into the firmware of DVD drive to see how it handles that and I think that would be a lost cause because it doesn't do imaging per se. It just detects the presence of pits. I doubt it has an actual frame buffer.

If you want an imaging system I think a better option would be one of the many USB microscopes that are available. Here is one example : https://www.amazon.com/Microscope-Magnification-Inspection-Compatible-Smartphone/dp/B07PVMRZQH/ref=sr_1_4?crid=337KLJ1CMJUIC

Of course it will because a function returning void will NOT have a result type. How can it?

Please note that I wrote MyWindowClass. That means you have to implement this handler in a class with a window and a message loop. CDocument classes almost always have a CView-based class and the CView class has methods to access its associated CDocument object.

That's a rather trivial one. Try just changing the % to a /. Then you have a solvable equation that is a bit less trivial : 30=(x+38)/4;

If you analyze the algebraic steps taken to solve the equation you can correlate them to the parsing tree that (most) expression evaluators generate.

There probably is code around that can do this but the point of most homework is to do it yourself. A secondary point of it is to learn how to find what you need for yourself.

Your program should solve them exactly as you would do it yourself. An expression handler would be a good front end to use.

You actually expect us to ask chatGPT what a DP solution so we can help you with a problem?

Guess again because it ain't happening.

It appears to be the number of times an '_' is encountered in ans which should be n times. I think you should try this in a debugger to find out for yourself.

Permutations are the key to the problem. They are essentially just all the ways you can shuffle the letters of a string. That's what you have to do - check each permutation, shift it, and see if it is circular. I don't think that qualifies as a DP solution.

Interesting problem. What is a DP solution?

In this situation I would use a va_list and vfprintf. That would also require fopen and fclose to use a FILE object but that's OK.

The code looks OK. If you have it working on one set of machines you have pretty well verified it is OK. Note that on your home network you are likely to have all machines on the same subnet, usually the class C subnet, so that tends to reinforce my hypothesis.

Do you have a question?

Also - your program deals with prices and discounts. What do bugs have to do with it?

One other thing, not all control paths return a value in f. If q is less than N then nothing is returned.

Well keep trying. You will learn nothing if others do this for you.

Here are some hints : you have variables z and o, presumably to count zeros and odds. Add another one to count evens and I am sure you can come up with a name for it.

You seem to be aware of the modulus operator and have snippets for determining if a number is even. Generally speaking, if a number is not even it is odd.

It is now up to you to tie it all together.

Your code is incomplete because the types of variables song1 and song2 are not shown. That is likely to be the problem but we can only guess.

This is probably not the best way to help someone with their homework.

I don't have an answer for you but you might find something useful at this guy's site : https://iquilezles.org/

Yes, this program already uses a function to do it.

Great, I am glad to read that you succeeded.

One detail : ZeroMemory does not free memory - it sets it to all zeros.

For what?

It's defined in wtypes.h, among other places, so at a minimum that file can be included.

If I was doing this I would read all input from a file using fgets. This would make your testing much faster and easier. You can still read input from the console by using stdin as the file pointer if you want or need to.

So that's your project - what's your question?

I do not understand your reply. What you have to do is define a mapping between your application's minimum and maximum values to the slider's position limits and then translate the slider's position back to an appropriate value for your application. That's all there is to it. Handling mouse moves for a slider is NOT the right way to do this. If you want to move the mouse around and have your display respond to that then maybe a slider is not the right way to deal with it. I have done both of these - I have displays that I pan around when the user presses the left button down and then it stops when the button is released and no slider is involved in this. I also have displays that adjust themselves dynamically as a slider is moved. I also have displays that have both of these mechanisms combined but the slider is not affected when the user pans around. You need exactly how you want your display to work because it is not clear from your messages.

Good idea.

You are still recursing on main which results in starting all over again with a new list. You also implemented your specializations but not the basic operations. This not how a linked list should be built.

Step 1 is to find an API that will let you do the job. I believe that will need to come from the manufacturer of the fans or the motherboard since there is no industry standard for that but I am not certain.

Step 1 is to find an API that will let you do the job. I believe those are specific to the manufacturer of the fans since there is no industry standard but I am not certain of this.

I would change get_coins slightly to :

int get_coins( int * pcents, int coin )
{
    int number_of_coins = 0;
    if( * pcents > coin )
    {
        number_of_coins = * pcents / coin;
        *pcents -= number_of_coins * coin;
    }
    return number_of_coins;
}

this will cut down the code a bit :

    int quarters = get_coins( & cents, 25 );
    int dimes = get_coins( & cents, 10 );
    int nickels = get_coins( & cents, 5 );

This does not appear to be the standard STL file format. Is it a proprietary format? The standard is documented at : https://en.wikipedia.org/wiki/STL_(file_format).

Personally, I would make the triangle structure out of vertexes like this :

struct Triangle
{
    Vertex v1;
    Vertex v2;
    Vertex v3;
};

and then I would implement basic math operators for a Vertex, starting with subtraction. The first few lines of the distanceToTriangle function would look like this :

double distanceToTriangle( const Vertex & pt, const Triangle & triangle )
{
   Vertex u = triangle.v2 - triangle.v1;
   Vertex v = triangle.v3 - triangle.v1;
   Vertex w = point - Triangle.v1;
   // and so on

I did not see any obvious errors. One thing I don't understand is why must requiredItems.size() be 5? You have that in the code twice but there is no mention of it in the description of the problem.

One thing I prefer to do is define a type or a using statement for repeated non-trivial types. Here are some examples :

using pairstrstr  = std::pair< std::string, std::string >;
using vpairstrstr = std::vector< pairstrstr >;
using uosetstr    = std::unordered_set< std::string >;

This is because it simplifies a lot of things in my opinion. Your function prototypes would become :

bool ViolatesConstraints( std::string item1, std::string item2, const vpairstrstr & constraints );
void FindRequiredItems( std::string item, const vpairstrstr & inclusions, uosetstr & requiredItems );

I think that is much easier to read.

That means it is time to learn the debugger. A side-effect of learning the debugger is it encourages you to write code that is more easily debugged. I recommend that you start at the beginning and verify that your data structures all look correct. Then check your first function - ViolatesContstraints. Make sure it works as it is supposed to and then move on to the next one.

"It's not working," is not particularly useful. It is much more useful to note exactly what is happening.

You should read it again because there are a few things mentioned there that you are not doing. One is allocating the buffer for the string.

Every compiler of any worth will tell you the line number where the error is. Do you expect us to guess where it is?

No, you don't have to reinstall. You can just add that to your existing installation.

This might be useful : https://www.microsoft.com/en-us/download/details.aspx?id=56846. It is a reference of windows commands.

Does one have to really get into ZPL or will the windows printer driver take care of all that?

Yes, arrays are the traditional approach. You can either allocate a whole bunch of them to start or implement a re-allocation scheme. Even then, there are more options. You can make your own pseudo-vector things like a free pool to save on re-allocations or re-allocate them one at a time. The function for re-allocation is realloc.

I assumed you could use vectors since you are using strings. Here is some documentation on vector : https://cplusplus.com/reference/vector/vector/. The key function of interest is push_back. When I use a vector I almost always call reserve to pre-allocate about as much memory as I think I will use so I don't thrash the heap too badly with re-allocations.

Your first two sentences are incorrect for windows. They CAN be used between machines and I have done it myself. Here is what Microsoft has to say about them : https://learn.microsoft.com/en-us/dotnet/standard/io/how-to-use-named-pipes-for-network-interprocess-communication. I have no idea about using them with Linux.

This is one of many reasons that using global variables is not recommended.

Are you sure that pipes between Linux and Windows machines are compatible? I am not at all certain they can work together and everything I have read says they can not. I think you would be better off using a socket connection because those CAN work between different operating systems.

What is your question? If it is "will you write this for me?" then the answer is no.

You are opening a file for write access but nothing is written to it so that is unnecessary.

As mentioned, using gotos is not recommended. There are at least two alternatives : use functions or use looping constructs. The keywords continue and break are very useful with loops. The three looping options are do, while, and for. This page : https://cplusplus.com/doc/tutorial/control/ is from a tutorial and it covers flow control mechanisms including loops.

The word is please.

Can the code compile? Does it work? It looks to me like it should.

k is used as an index into the A and B matrices.

There are several optimizations you can do with this. Here is one hint : you do not have to actually compute the factorial since the result you want is the sum of the digits, not the actual factorial value. Think about how factors of ten work - 10, 20, 30, etc...

Why should anyone do YOUR work for you?

See if something was lost in translation. Copy and paste what you had for that line and then change the variable names as I made them and see what happens.

I noticed a potential problem just now. I named a variable 'class' and that could be a problem. You might want to change it to clas with one 's' to be safe.

That does not look like C++.

Google will give you a lot more information far faster than asking questions at this site will.

Do you have a question?

What error does it result in?

Your function is named a bit strangely. It is called GetRegStrValue but it calls the function RegCreateAddSetString. To me, this is a side effect that I would not expect from a function with that name.

Usually a debug assertion failure will also tell you where the assertion occurred. Without that knowledge there is nothing anyone can do to help you.

I recommend that you never, ever have a 'using' statement in a header file. If you want to shorten the expression std::string then consider a type defintion.

A do-while loop will always execute at least once. A while loop may not.

We don't always get what we want.

Your question is unclear. If this is software you have control over and it's for windows then spin buttons have a property that defines their orientation. If you do not have control over this software then there is probably not very much that can be done.

I am not going to guess why. One of the most important skills to learn for a programmer is debugging. This would be a good time to learn how to use a debugger.

Thank you sir.

Sorry, I hadn't seen your solution when I wrote mine which looks rather similar.

Why are any of those variables floating point? None of your math involves fractional values or division so there is no reason they can't be integers.

Thank you sir.

No.

Not exactly but it might work.

Thank you sir.

That is not how the Scrabble game works. Players put down letters onto the board as they play various words. The board has various squares designated for double or triple letter and double or triple word scores. You do need a table of words that are allowed to be played (your dictionary) but that is only used to validate the words that are played.

What you described sounds more like a crossword puzzle.

The word is please.

Help do what? Your code is incomplete.

How can debug mode be right when it fails to invert the matrix?

The fact is we can't help with anything when we can't see your code.

In my opinion, no. As I wrote, I prefer to use fgets because I do not want to ever have to concern myself with flushing the stream. I always write code that accepts input from a file so that's another reason I never use scanf. You might want to have a look at the function sscanf. It is scanf that operates on a string.

We are here to help you solve problems. We are not here to do your work for you.

I really do not what best practice is when it comes to drivers because I do not write drivers at that level. I have written lots and lots of drivers but they were all user-mode. If you do everything you need to do in C then that would probably be best for the driver since it will export C functions. If I am not mistaken, all of those articles discuss DLLs.

The word is PLEASE.

That would be my preference. I never, ever use scanf but then I never acquire input from a console. I rarely call sscanf either. I prefer to tokenize the input and then deal with each token on its own.

For a full-featured CStatic-derived control, have a look at this : https://www.codeproject.com/Articles/215/Extended-Use-of-CStatic-Class-CLabel-1-6

What was changed?

Probably. That would explain the lack of a clue about it.

Do you really not see the problem? It is obvious to me. Hint - it's in the main function.

Then YOU need to write it.

In my opinion, the issue is your answer value is an integer and you are scaling by 100000 which is exactly the precision your problem requires. That means you are within one of it so it could be something as simple as a rounding issue. Try making the scale factor 1,000,000 and see how close you get.

Note how many places you will have to change numbers. That is why things like this scaling factor should be definitions or constants so you only have to change one value.

The only reason I can think of is that doing it without loops would force them to use STL algorithms.

good point. I hadn't even look at that.

It didn't all get posted. Some is missing. Also - remember to add the code tags around it.

After looking around a little, I found there is std::lock_guard that does exactly this. I learned something new today.

Thanks, good idea.

I recommend using the search engine of your choice. I found lots of stuff about the topic so I am certain you can too.

Thank you, sir.

One other thing that just occurred to me - when you access the value from the array and return it in pop, you could also null the slot. It is possible that you are trying to access an object that was already deleted and this is likely to happen when you reach the end of the array and wrap around. It might help to if you check for that condition (null pointer) and catch it when it happens.

I write lots and lots of multithreaded code and it is very tricky to debug. I (nearly) always do it in two phases. If possible, I first thoroughly debug the algorithm. That is not always possible like with a reduction algorithm, for example. Then I debug the locking, when it is used. When possible I avoid locks but your algorithm requires them so I make sure that works correctly. Then it's integration time where the whole is tried together. I would guess you have an array indexing problem. I would add output statements so you see every array index accessed and use a temporary variable for that as I did in the snippet above. Also - output the value returned from pop. That pointer is dereferenced to execute the function queued and it is likely that it is the errant pointer that causes the exception. I would add more output so you can see what values result in the exception. One more thing - you use a default of 4096 for the array size. If you can, try it with much smaller values like 8 or 16 and see if the same things happen. If the behavior is the same then you should see it happen much sooner which will make it easier to debug. Personally, I don't like how you handle the array index. I would never do it that way, but that's just me. I would limit the values and force them to wrap around instead of masking. Again, that's just my personal view.

I have no idea where or what your problem is. I am just pointing out that find is the way to find a value associated with a key so read the documentation so that you understand that. You are already calling it twice in your code. Maybe you should consider using a debugger. I find them invaluable.

For each section there is an array of cages. What I showed you was the array for one section. Next you will need an array of structures for each section. Solution 3 shows how that can be done and similar techniques can be used to allocate those arrays.

I already showed you - find : https://cplusplus.com/reference/map/map/find/

The word is please.

If you are going to implement your own function you should start by making a list of number fragments. This can be done many ways. One is to separate the digits and then build the fragments from the digit list. Once you have a list of the fragments it should be very easy to check their divisibility.

It would be more appropriate to call the function DivisibilityByEleven.

Doesn't this have a diamond problem? https://www.cprogramming.com/tutorial/virtual_inheritance.html