|
- Use MFC class Wizard to derive new MFC class from CStatic (say CMyPicture);
- Change the control ID of your picture control from IDC_STATIC to something more sensible (like IDC_MYPICTURE);
- Use MFC class Wizard to create the control member variable (of the new created type CMyPicture) for your picture control.
Also see MSDH (docs.microsoft.com) for details.
|
|
|
|
|
Thank you.
Will give it a try.
|
|
|
|
|
Does someone have a code in c, for a battleship game, i have to do it on codeblock
Thank you
|
|
|
|
|
You should try doing it yourself.
It's more fun.
I'd rather be phishing!
|
|
|
|
|
Sorry, this site does not provide code to order.
|
|
|
|
|
Julien JG7 wrote: Does someone have a code in c, for a battleship game, i have to do it on codeblock
So if YOU have to do it, why are you asking for SOMEONE ELSE's code? 
"One man's wage rise is another man's price increase." - Harold Wilson
"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons
"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles
|
|
|
|
|
What is a common way to use NASM (or other assembly compilers) when developing windows applications. Do you integrate it with VisualStudio shell or you go down the path of always using the command line?
|
|
|
|
|
|
The usual way to integrate assembly files into a C++ project is to add the MASM "build customization" (right click a project, go to Build Dependencies > Build Customizations, check the box in front of MASM). Then you can include .asm files as normal sources without needing to do anything weird. You can install vsyasm and use YASM that way, if you prefer a more NASM-y syntax. Using NASM itself is possible, but as far as I know there's no nice integration like that, you can set it up manually as a custom build tool.
Similar information is in microsoft docs.
|
|
|
|
|
thanks harold aptroot, Richard
modified 25-Jan-21 4:09am.
|
|
|
|
|
Hi,
I recently upgraded the solution from VS 2015 to VS 2017 enterprise edition. When i build the solution am getting this error.
Error LNK2019 unresolved external symbol _vsprintf referenced in function _COND_PushCondition ctn_lib.lib(condition.obj) 1
Any clue is highly appreciated.
Kind regards,
Suresh
|
|
|
|
|
That is part of the standard C run time libraries so it should always be found. You may need to rebuild that library.
|
|
|
|
|
Thanks and it is working now
|
|
|
|
|
can anyone give me code c++ that read swedish txt file read
|
|
|
|
|
How do Swedish files differ from any other txt file?
Because it contains text in Swedish? Are you looking for a function that can give you the text in English? Try Google Translate!
|
|
|
|
|
|
Try Swedish-C++.
"In testa che avete, Signor di Ceprano?"
-- Rigoletto
|
|
|
|
|
Reminds me of when I was asked to send text files with "larger fonts" since the usual recipient had a hard time reading the "text" reports.
It was only in wine that he laid down no limit for himself, but he did not allow himself to be confused by it.
― Confucian Analects: Rules of Confucius about his food
|
|
|
|
|
Hello,
I am searching for tools that allow you to design a state machine and generate the corresponding C code. As a bonus, I would like the tool to:
- given the source code, generates the state machine
- allow to easily switch between a State Machine view (high level), to source code view (detail, low level)
- the State Machines are saved in a Git/CSV/SVN friendly format
Any suggestions ?
I easily found Home - Modern Embedded Software | Quantum Leaps[^], but found it to have a too steep learning curve.
|
|
|
|
|
There's a member on this website named Honey the Codewitch.
This member is quite knowledgeable about compiler design and has written several articles that you might find very helpful.
Search for articles by this member.
The difficult we do right away...
...the impossible takes slightly longer.
|
|
|
|
|
|
Hoping for some program to translate a C program (in the sense "an arbitrary C program") into a state machine is naively optimistic.
Even if that C program was initially generated from a state machine model, so you could hope to recognize code key patterns allowing you to identify code fragments handling specific state transitions etc., most programmers feel the freedom to not give a sh*t about FSM principles, so they toss the code all over the place, making it impossible to recognize the pieces.
What you can do is to provide a framework for editing the FSM as a FSM, and let the developer specify the actions of each individual transition within that framework. Then, the framework can lay out the code for each transition (as well as the common logic for the state transitions themselves).
This is actually one of my current pet projects. Maybe I will write a CP article about it some day. It is far from ready yet, but if you would like to discuss it directly with me, send me an email. Maybe that could help pushing my hobby project forward 
|
|
|
|
|
Quote: Hoping for some program to translate a C program (in the sense "an arbitrary C program") into a state machine is naively optimistic.
100% agree with you. I meant that the tool/framework could generate the FSM some code itself had generated. It should be easier, although not trivial at all.
Quote: What you can do is to provide a framework for editing the FSM as a FSM, and let the developer specify the actions of each individual transition within that framework. Then, the framework can lay out the code for each transition (as well as the common logic for the state transitions themselves).
That seems something more reasonable to do. My worries in this case is switching between the FSM view and the source code view. It should be easy to edit an FSM, generate the source code and then let the programmer add custom code to actions. But how to you proceed when the user wants to edit the FSM ? What happens to the custom logic that was added ?
Quote: This is actually one of my current pet projects. Maybe I will write a CP article about it some day. It is far from ready yet, but if you would like to discuss it directly with me, send me an email. Maybe that could help pushing my hobby project forward
Will do 
|
|
|
|
|
My approach is to do all model editing in the FSM editor. Anything related to state transitions, testing whether a transition is legal, possible transfer to an error state etc. etc.
When the general FSM logic has done its job identifying a transition to be taken, there frequently is a set of updates to state variables, beyond the ID of the new state - it could be things like starting a timer, zeroing a buffer or setting flags that are tested by future state transitions. These are all specified in a general way in the FSM - think of it as quite formalized pseudocode. This is where code editing comes it: For that specific set of state variable updates, the coder writes a "real" implementation. This usually goes little beyond simple assignment statements.
Then a transition may have side effects - generally: raising events in other FSMs. Sending a message is an example. Even this is specified in formalized pseudocode in the FSM, and the developer translates that logic to some real code.
The FSM is edited as a state table - a set of squares in the crosspoint between current state and event. Each square identifies a condition for the transition to be legal (as a logic expression on a restricted set of bool functions). Then comes the ID of the next state if the transition is taken, followed by the ID of the function updating the state variables (which also is usually a limited set), and the ID of the function taking care of the side effects. Clicking on either of these four fields to take you to the details of the function.
One thing I picked up from rather complex OSI protocol state machines: If the test on the state variables shows that a transition is not legal, maybe some other transition is legal. (The very trivial case: If a state variable x is true, make this transition, otherwise make that transition.) Purists say that this should be treated as two completely indepenent states, but allowing tests on other variables than just the current state is essential to avoid an explosion of states.
The general FSM editing is independent of programming language. From the tables, a code skeleton can be genereated, calling those functions for testing and updating state variables and causing side effects that the programmer wrote. So you may have one common FSM model for different languages, provided that you have written a skeleton generator for each relevant language.
One remaining "problem" (if it is): My generator will produce a complete set of source files that may be set up e.g. as a Visual Studio project for complilation. What happens when the compiler reports a syntax error? Or debugging reports a logic error in one of the functions? As is is now, the developer must go back to the FSM editor to make the correction there, generate a new set of files, and recompile / rerun. This is not acceptable in the long run. I plan to learn how to write VS plugins, to attach the FSM editor to VS, let the user edit each function and then, based on coded comments in the source, bring the edits back into the FSM model. If the problem is not in a single function, but in the FSM logic, then you skip into the FSM editor, doing the changes there. This is certainly some way from being completed...
If you have been thinking along simlar paths, feel free to present an introduction.
|
|
|
|
|
Your project might move along faster if you targeted your FSM editor to my session processing framework in the Robust Services Core sb[^] directory. I've yet to write any CP articles about it, because the lower level parts of that code base are useful to a much wider audience. But there's a fair amount of documentation[^] and examples; scroll to the bottom of that page. It's essentially the framework used in a GSM MSC that evolved to LTE and is still seeing development. It has run-time support, TLV messaging, state machines that can observe and override the behavior of others, and even overload controls. A tool would be very useful even if it simply generated the C++ boilerplate needed when deriving from the classes defined by that framework.
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
