Project Hilo and promised a set of cool sample applications written in C++. At that time we had released the first application in the Hilo series. Since then we have published some articles that walk the reader through all the steps that go into developing the Hilo Browser application (Chapter 1 thru 8 on this link). These articles describe the way we implemented the application in C++, our thought process for designing the application, as well as deep discussions on the source code and implementation using C++ and the modern application features in Windows 7.
Mon, 23 Aug 2010 18:25:57 GMT - In May this year, we announced Project Hilo and promised a set of cool sample applications written in C++. At that time we had released the first application in the Hilo series. Since then we have published some articles that walk the reader through all...(read more)
Sat, 14 Aug 2010 00:34:43 GMT - The third part of my video lecture series introducing the Standard Template Library is now available, following Part 1 and Part 2 . Part 3 covers unique_ptr , shared_ptr , and exception handling (briefly). It explains my solution to the container erasure...(read more)
Tue, 10 Aug 2010 00:26:00 GMT - My name is Ahmed Charles and I currently work on Windows Error Reporting. I believe that this is the first time that someone not on the VC team has written a blog, but I hope you will find it useful anyways. I’d like to thank Stephan T. Lavavej...(read more)
Thu, 22 Jul 2010 22:37:04 GMT - The second part of my video lecture series introducing the Standard Template Library is now available. This part covers the STL's associative containers and the erase-remove idiom. It assumes that you've watched Part 1 . More parts are on their way! Let...(read more)
Wed, 07 Jul 2010 20:39:00 GMT - The C++ back-end team is very conscious of the performance of our product. Today I will present to you an overview of how we define “performance of our product” and the way we measure it. Along the way I hope to introduce you to some new ideas...(read more)
Fri, 02 Jul 2010 21:41:26 GMT - I recently recorded the first part of a video lecture series introducing the Standard Template Library. It assumes familiarity with C++, but begins with the STL basically from scratch. Channel 9 hooked up my laptop so I could write, compile, and execute...(read more)
Fri, 25 Jun 2010 16:12:37 GMT - The Visual Studio Debugger Team is currently planning features for the next release of Visual Studio. We would like to hear from our C++ developers to make sure that their needs are understood. Please take a couple of minutes to complete the very short...(read more)
Fri, 18 Jun 2010 15:17:24 GMT - Recently we announced the availability of Visualization and Modeling Feature Pack for MSDN subscribers which complements the Architecture tools in VS2010. There is great C/C++ code visualization support in there. Read a blog post by Somasegar here: http...(read more)
Tue, 15 Jun 2010 20:59:19 GMT - Security is something we take very seriously and we work with a number of teams across the company to keep native apps as secure as possible. An example of this in Visual Studio 2010 was our work on the GS flag . One of our colleagues, Tim Burrell, who...(read more)
Hello, this is Jim Springfield.This post will cover some low-level details about how we represent information in the browse database in VS 2010.As I’ve mentioned in a previous post, we are using SQL Server Compact Edition (SSCE) for storing information about all of the C, C++, and IDL files in your solution.I will show some SQL examples that illustrate how to mine this database for information about your code.
NOTE: The particular database schema we use in VS2010 may very well change in future versions, so the examples I show may not work in future versions of VS.
Opening the SDF file
The database file (SDF) can normally be found in the same directory as your solution file (SLN), although it may get relocated if your SLN is on a network share or a flash drive.You can open the SDF using several different tools.SSMS (SQL Server Management Studio) is a good one if you have access to it.However, you can also open it in Visual Studio itself.Before opening the SDF to play with, it is best to close the associated solution.
1.Within VS, go to the “Server Explorer” window, right click on “Data Connections”, and select “Add Connection…”.
2.Select “Microsoft SQL Server Compact 3.5” for the Data Source and click “Continue”.
3.Click the “Browse…” button and then navigate to the SDF file to open.
4.If the SDF file is large (i.e. > 250MB), you will need to set an option before opening.To do this, click the “Advanced…” button and set “Max Database Size” to something larger than the SDF you are opening.4091MB is the largest value allowed and you can just use that if you wish.
5.Finally, click the “OK” button and VS should open your SDF file.
Learning your way around
If you expand the new node for your SDF in Server Explorer, you will see a “Tables” node.Expand that and you can see all of the tables that are currently defined.The “code_items” table contains information on every definition and declaration that occur in your source.I don’t have space to cover what all of the tables do, but take a look around.Don’t expect to see data in the refs or symbols tables as those are there for some possible future use.
Note:Don’t try to make changes to the schema or indexes and expect that to persist.When we open the SDF for actual browsing use, we do a consistency check and if anything is not “correct”, we delete the SDF and rebuild it.
Take a look at the “code_item_kinds” table.You can see the contents by right-clicking and selecting “Show Table Data”.There should be 59 entries here.These values are used in the “code_items” table and you can use them in queries to find certain types of code items.
Creating a query
Right click on the “code_items” table and select “New Query”.You will get a query window with some tools that help you build and run queries.A window will popup asking you to add a table.Just click close as you will just be copying queries into the query window for now.
Try this query first to get your feet wet.To run a query, click the red exclamation icon in the toolbar or press “Ctrl+R”.
select * from code_items where kind=1
This query returns all code items that are C++ classes.If you look at all of the columns, most should make sense.Note that the database gives start and end position information for the entire class and just the name portion of the code item.It is hard to see what file a code item comes from, however, as the code_items table uses a file_id and not a filename.To see the filename as well, try the following query which does a join with the files table to get the filename.
SELECTf.name, ci.*
FROMcode_items AS ci
INNER JOIN files AS f ON ci.file_id = f.id
WHERE(ci.kind = 1)
One thing to notice is that this query returns information on code items that occur in your own code as well as in the SDK and other headers.You can return information for files that are explicitly in your solution by using the “config_files” table.This table has a column that indicates whether a file is implicit or explicit.A file may have multiple entries in the config_files table as a file can be used in multiple configs/projects.The “DISTINCT” keyword prevents returning duplicate copies of code items.
SELECTDISTINCT f.name, ci.*
FROMcode_items AS ci
INNER JOIN files AS f ON ci.file_id = f.id
INNER JOIN config_files AS cf ON ci.file_id = cf.file_id
WHERE(cf.implicit = 0) AND (ci.kind = 1)
The parent_id in the code_items table refers to another item in the code_items table.Using this information, you can get some parent/child information.The id of 0 is the global namespace.So, to get all functions in the global namespace you could do this.
SELECT*
FROMcode_items
WHERE(kind = 22) AND (parent_id = 0)
You can also join the code_items table to itself to find a set of code_items whose parent matches some set of criteria.The following example finds all functions whose parent code_item is named “ATL”.
SELECTci1.*
FROMcode_items AS ci1 INNER JOIN
code_items AS ci2 ON ci2.id = ci1.parent_id
WHERE(ci1.kind = 22) AND (ci2.name = 'ATL')
I have only scratched the surface of what you can do to mine the SDF for interesting information about your source code.There are many other ways to leverage the data contained in the SDF to gather information about your source code.All of our browsing features for C/C++ are implemented on top of the SDF.We do take advantage of some caching, prepared commands, and the special “table direct” mode that SSCE provides in order to increase performance, but everything comes from the SDF at some point.
The query processor in SSCE is limited in some ways, but you could even replicate the data from the SDF into a full SQL database and perform even more complex queries than are allowed by SSCE.
My name is Alex Thaman and I am a Senior Test Lead on the Visual C++ compiler team at Microsoft.The focus of this blog is testing of the compiler backend where I’ve spent a good portion of my time here.For those not aware, this is the part of the compiler that takes an intermediate representation as an input, does optimizations and code generation.
I will walk you through the compiler backend testing domain, the kinds of bugs that the backend compiler deals with and how we go about testing the backend compiler.
The Compiler testing domain
Compiler testing exists in a different domain than many other kinds of application or system testing.Here are a few attributes of compilers that inform how we think about testing:
·Compilers have short-lived execution times like most other command-line tools.By “short” I mean that it runs, does some work, outputs some files, and exits.
·There is no user interaction during execution.
·Compilers execute in phases, where at each phase a transformation is applied to the input and the output becomes the input of the next phase which makes each phase interdependent. Also this means it can be difficult to construct test cases that to reach specific code paths, especially in the later compiler phases.
·Many compilers do analysis at the entire program level, so data about the entire input set may be sitting in memory and may all be operated upon at once
·With some exceptions, compiler outputs cannot easily be verified by inspection or other kind of test tool.They need to actually be executed. One reason is that there are many correct outputs in terms of machine instructions, another is that the output can change from day to day and still be correct, and lastly the output is very large compounding the first two issues I mentioned.
Bugs
Below are the categories of bugs that we deal with on a day-to-day basis in the compiler:
·Compiler crashes (also known as an ICE or Internal Compiler Error) – This is simply some kind of failure during execution of the compiler
·Compiler hangs – Some kind of infinite loop in the compiler.Because the compiler back-end is single-threaded, there is no possibility of application-level deadlocks
·Incorrect error/warning output – This can be either an error/warning that fired when it should not have, or an error/warning that should have fired but did not.The latter case is interesting because it is often not so much a bug but a limitation in the feature, at least in the case of warnings.Some warnings require some extensive code analysis to fire in all the cases that they should.We do make efforts to ensure that we are giving customers the best possible information when they have done something incorrect
·Bad code generation – This is a result of incorrect compiler output and is by far the most devastating bug of any kind.There are two classes of bad code generation:
a)Bad code generation that leads to a crash in the application – These are the less problematic of the two cases because of the effects and due to the ease of discoverability.The effect is an application crash which in many cases is resolved with a restart and does not corrupt data.It is (typically) easy to pinpoint the bad code generation because the crash gives you a call stack and you can see in front of you what got corrupted.
b)“Silent” bad code generation – These are the worst kind of bugs not only because these bugs can result in data loss but tracking them down in some cases is extremely difficult because it’s not always easy to find what got corrupted and where it got corrupted.You can imagine that this problem is worse for a multithreaded app – we have seen silent bad codegen bugs where a variable’s volatile attribute has not been honored in a certain loop.Sometimes silent bad codegen is a result of what should have been a crash due to overwriting invalid memory, but a memory location happens to contain valid data.An example would be if you set i = 100 but instead of writing to i, it overwrites j.This is just an example – it never manifests in this easy of a form
·Compiler throughput issues – Issues that affect the amount of time the compiler takes to compile code
·Code quality issues – Issues that affect the performance of the compiled application
·Compiler feature correctness issues – This class of bugs involves the compiler generating correct code, but not doing what a particular feature specifies should be done.An example here would be not adding a security cookie when the /GS switch is passed.In this case, the code would execute just fine but would not have the same buffer overrun security protection that the user would expect
·Other peripheral behavioral issues – There are things related to compiling that can be affected by compiler bugs.The biggest example is debugging information, where the result is typically seen in the form of the debugger not doing what you would expect
One last thing to note is that the most interesting testing space for the backend is specifically optimized code.A non-optimizing compiler does not do all that much work, and though we do test the /Od compilation, we don’t spend a lot of time with it and it generates far fewer bugs, and the same goes for monitoring /Od build times and /Od code generation.Note that Debug build times in an end-to-end scenario are measured quite often, but the compiler backend generally contributes only a small portion to this.
How Do We Test?
Now that I’ve explained the compiler testing space and the kinds of bugs we deal with, I’ll explain how we actually test the backend.
Writing Tests
We create A LOT of tests, really A LOT of tests J.We’re talking on the order of hundreds of thousands of small tests.To understand why, try to think of how you might test exception handling (EH).You might come up with simple cases involving a test throwing an exception and catching it, throwing and not catching, simple nested exceptions, etc.These are pretty basic, and would constitute tests that a developer would run before every check-in just to make sure the product works at a fundamental level.We also have a much larger suite of tests to verify that our compiler EH code generation is ready for production.Without going into too many details, we have to ensure that throwing of various kinds of objects (including ones with copy constructors and destructors that get called during stack unwinding), dealing with weird control flow around EH (what happens when you have a goto from a handler to outside the try?), etc. all works as the user would expect.You can see that this matrix of cases can explode.I have not actually counted but I would guess that we have a few thousand tests that involve EH.
Test Permutations
To add to this matrix, the compiler also has a few switches that have big effects on what is done with the code.The most interesting “set” of switches is /Od, /O1, /O2, /O2 /GL, /O2 /GL /link /ltcg:pgu.We run this matrix as a permutation of most of our tests.We have many other switches, but those are tested in a more localized fashion since applying them broadly to most tests is not as interesting as the optimization controls.The last big dimension of our matrix is /clr – almost all of the tests that we have that are supported under /clr are tested with this switch as well.
Real-World Code
Given the infinite set of inputs, there isn’t a systematic way to test everything in the compiler in an efficient way. However the C++ compiler has a big advantage in terms of testing – people have already written test cases for us!Anyone who writes code has a test case.As a result we rely heavily on what we call “real world code” (RWC), which are just real under-development applications.You can be assured that the C++ compiler we ship to you in Visual Studio 2010 has already successfully built Visual Studio itself, Windows, SQL, Office, and many other large software applications.Another advantage is that this code is under active development, which means that every day is a new test case as the developers churn on the code.We frequently release our compiler to internal developers and fix the bugs that we get from these developers. What is released in Visual Studio 2010 has been through an extensive grind within Microsoft.
Performance Testing
Performance testing is a critical part of what we do.For the optimizing backend, this tells us how well our features are working.Because the output of the compiler involves performance, there are actually three forms that performance takes on the backend team.
1. The first is what we call “code quality”.This is typically the speed of the code that is generated.We use a diverse set of performance tests to cover various kinds of code that we might be compiling in the real world.In most cases we are hyper-sensitive to noise, and even 1% noise on these benchmarks makes it difficult for us to see how we are doing, because true performance regressions can often come in 1% increments.
2.The second is “code size”.This is actually closely tied to code quality.Code size alone is only somewhat interesting in that we don’t want to generate very large images, but it often correlates to code quality.Optimizations will often trade more code for faster code, the two easiest examples being the inliner (which will reduce call overhead and provide additional optimization opportunities) and the loop unroller.One disadvantage we have in measuring code quality is that it requires execution of the code in question.Code size can be measured by just building.We will not always try to reduce code size for every change we make, but we will watch it as an indicator of how we are changing things.We will typically measure code size on the benchmarks that we already use for code quality plus some of our real-world code.
3.The third is “throughput”.This is a measure of how fast the compiler runs, i.e. the build time.This is most interesting to watch when optimizations are turned on because this constitutes the bulk of the execution time in the compiler.We realize that build time is important to you and this we keep an eye on this metric to make sure that you remain productive.
Stress Modes
With all of that said, because there are just so many code patterns and possibilities, we still can’t catch everything with those efforts alone.This requires us to start getting more creative with the testing.One area that has shown the most promise is running compiler stress modes.There are two classes of stress modes that we have:
1.Ones that actually change the input in some way, such as add a try/finally around the body of every function, mark every variable as volatile, etc.
2.Ones that change heuristics for optimizations/analysis, such as inline every function instead of ones that give a benefit.
Stress modes are extremely effective in taking existing tests we do have (including real world code) and creating new and interesting cases out of them.There are two main challenges with stress modes:
1.Not increasing the size of the matrix too tremendously, so specifically determining what tests should be run with each stress mode.
2.Making sure a stress mode does something that is legal.That is, a test run under a stress mode might fail but it is because the stress mode did something that makes the code incorrect.Depending on the case, it could be considered a bug in the stress mode or it could be an incompatibility between the test and the stress mode.
These aren’t major barriers, just things to keep in consideration as it requires that we be selective in which tests we want to use with our stress modes.
Auto Test Generation
In certain cases, we can use test case generation tools to assist us in testing parts of the compiler.One of our team members created a generator for exception handling tests.Because the matrix is so large for exception handling, and because the cases are easy to construct by modeling the EH code as a tree, we were able to create many different cases on the fly by generating trees where the nodes involved various constructs that later turned into C++ exception handling code.
There is a lot more to explore in this area that we would like to look at for the future.
Test Harnessing
One thing that should be clear from the above is that it is *extremely* easy to place our tests in a system that can execute them.We don’t require complicated harnesses since our app is short-running and we don’t have to deal with the UI automation problem that many other testers in the world do because there is no user interaction.Most of our tests are just batch or simple perl scripts with some .cpp and .h files.Even for RWC, the applications we build are wrapped in either VS .sln files or some other build tool that the development team produced.This allows us to focus on writing a large number of small tests very quickly.The most difficult harnessing problem we face, which isn’t that bad, is the execution of real world code.For instance, testing the CLR requires installing CLR on a machine, and though we have tools to do this, it is certainly much harder than our feature tests that typically compile to a simple .exe that can be run.
The downside of this is that our tests only get one entry into the application under test.That is, we just provide some source files and some switches, and we have to make sure that this input tests exactly what we want even if it is in one of the later phases of the compiler.This makes it very difficult to test something like the register allocator in a targeted fashion, which executes much later in the compiler.In theory, the register allocator could be targeted by testing that phase in isolation assuming it had API’s to test with, but this is not something we currently have.Even then, coming up with a full set of test cases for the register allocator is a fairly hard problem due to the complexity.
This provides you with an overview of how we approach testing in the compiler backend, and how we ensure that you are receiving high-quality compilers from us.
Project “Hilo” is an effort to tell the story of building high performing, responsive rich Windows applications using C++. We will do this by walking you through our own experience of building some sample applications which we believe provide differentiated user experiences. We will tell you everything from setting up the development environment to taking advantage of the feature set of Windows 7.
The Samples
The first of these sample applications is a photo browser that implements a touch-enabled user interface for browsing photos on your computer. We call it the Hilo Browser. Below is a screenshot:
This application illustrates how to take advantage of the following Windows functionalities:
Direct2D: For high performance and high-quality rendering of graphics.
Windows Animation Manager: To give the application a unique personality and to improve the user experience.
Windows Touch: To provide a more natural user interface through which the user can just “point” and “do”.
Libraries: To enable the application to provide users with a single, coherent view of their files.
Shell API: To navigate the images, to optimize by using the pre-built thumbnail cache and also to provide folder icons from their actual content.
Over the coming weeks, we’ll be publishing a series of articles on MSDN Library (here) that will provide the walkthrough promised above. The introductory article is already up.
If you have questions or comments about the sample code, the usage of technologies or anything in general, please feel free to let us know through the Hilo Discussions Page.
You can also follow Hilo updates on Twitter @projecthilo.
We’ll soon be publishing the next article in the series, which will describe in detail how to prepare your development environment for Windows development. Stay tuned for more updates soon!
My name is Amit Mohindra and I am a Program Manager with the Visual C++ IDE team. In this post I would like to talk about project-to-project references. In VS2010 release we moved the C++ build and project system to be based on MSBuild. There is an excellent article written by Marian Luparu detailing the change and advantages of the new build/project system (http://blogs.msdn.com/vcblog/archive/2008/11/20/printf-hello-msbuild-n.aspx).
Project to Project references have existed ever since Visual Studio 6. However the term has evolved over the years. Native technologies used Project dependencies to define references prior to Visual Studio 8. With Visual Studio 8 native projects were able to define project to project references.
“Project to Project references” defines the mechanism in which Project A creates a reference to Project B, by which Project A consumes the output of Project B to deliver on its functionality.This feature is consumed by users who have large source code bases, a solution with many large projects and input of one project is driven by the output of another project.
Traditionally, there are three variables that control how project references work:
·Ignore Import Library (Set On the Referenced project)
Tells the linker not to try to link any .lib output generated from this build into any dependent project. This allows the project system to handle .dll files that do not produce a .lib file when built. If a project is dependent on another project that produces a DLL, the project system automatically will link the .lib file produced by that child project. This may not be needed by projects that are producing COM DLLs or resource-only DLLs; these DLLs do not have any meaningful exports. If a DLL has no exports, the linker will not generate a .lib file. If no export .lib file is present on the disk, and the project system tells the linker to link with this (missing) DLL, the link will fail.
Use “Ignore Import Library” to resolve this problem. When set to “Yes”, the project system will ignore the presence or absence of that .lib file and cause any project that is dependent on this project to not link with the nonexistent .lib file.
·Link Library Dependencies (Set On the Referencing project)
Gives you the choice of linking in the .lib files that are produced by dependent projects. Typically, you will want to link in the .lib file. If you don’t want to consume the .lib file generated then just set this Linker setting to “False”.
·Use Library Dependency Inputs (Set On the Referencing project)
In a large project, when a dependent project produces a .lib file, incremental linking is disabled. If there are many dependent projects that produce .lib files, building the application can take a long time. When this property is set to Yes, the project system links in the .obj files for .libs produced by dependent projects, thus enabling incremental linking.
In this design however there were limitations and the design wasn’t very flexible in allowing the project defining the reference to control the behavior. Consider the following very simple example:
-Project A defines project-to-project references to Project B and Project C (both Project B and C create .lib outputs). Project A wants to only consume the library output of Project B and not for ProjectC.
oIn VS2008, this was achieved by creating references to Project A with “Link Library Dependency” property set to “Yes” for Project A and subsequently setting “Ignore Import Library” for Project B to “No”.
§This approach however had a disadvantage in that if there was another Project D referencing Project B it would be limited by the “Ignore Import Library” property being set to “No”. The scenario shown in diagram above was not achievable in VS2008.
In VS2010 we have enabled the above scenario by supporting reference level metadata on the project references. Now you can set “Link Library Dependencies” and “Use Library Dependency Inputs” properties at the project reference level. To achieve the scenario above:
-Project A will create a project reference to Project B and Project C
-For the Project B set the “Link Library Dependencies” property to “False”
-Project D will create a project reference to Project B and Project C. In this case the global defaults for the properties (“Link Library Dependencies” set to “True” and “Use Library Dependency Inputs” set to “False”) will define the behavior.
To set these properties you can use the “Framework and References” tab in the property page of the parent project (Project A) as follows:
In VS 2008, Visual C++ had a couple of the simple scenarios called Custom Build Step and Custom Build Tool. This post will discuss a couple of the simple build extension options you have, and how they’ve changed since VS 2008. Andrew Arnott discusses these scenarios and how they work in VS 2010 here
Hi my name is Li Shao. I am a Software Design Engineer in Test for the C++ team. In my earlier blog “Visual Studio 2010 C++ Project Upgrade Guide”, I have mentioned about the change of Custom build Rules in VS2010. In this post, I would like to explain in more detail of the new format of the Custom Build Rules and some of its limitations in VS2010.
Custom build rule is a build feature introduced in VS2005. It provides the ability for the users to easily Plug-In third party tools to use in their build process. The custom build rule is defined by “.rules” files. Rules for MASM (Microsoft Micro Assembler) and LIC (License Compiler) are shipped in the box for VS2005 and VS2008.
In VS2010, due to the migration to MSBuild, the information in the rules file is represented by three files: .XML, .props and .targets files. The XML file defines the property and switch mapping. The props file initializes the property values and the targets file generates the task based on the XML file and has the build logic. MASM and LIC custom build rules are also shipped in VS2010 with this new format. In the next couple of paragraphs, I will use MASM rule as an example to explain some important parts of the new custom build rule format and hope to give you some ideas on how to read custom build rule files if you need to.
MASM custom build rule is available at %ProgramFiles%\MSBuild\Microsoft.Cpp\v4.0\BuildCustomizations or %ProgramFiles(x86)%\MSBuild\Microsoft.Cpp\v4.0\BuildCustomizations on x64 machine. You have the following in the MASM.XML file.
VS2010 supports automatic conversion of the .rules file to .xml, .props and .targets files. The new build rules, in general, can be built without any modification. However, there are a few limitations that may require additional modification to the rule files. I will use custom build rules comes with CUDA tool kit and custom build rules that work with YASM tool as examples.
Environment variables as part of the switches
One major limitation is that MSBuild does not support expanding environment variables if they are part of the switches when generating tasks. Take the CUDA rule, for example. You have the following in your original rule file:
The $(IntDir) and $(IntputName), however, will not be expanded during compile due to the limitation of the task generated by the task generator. As a result, you will see the following command line that $(IntDir) and $(InputName) are not expanded.
You can take a look of this post on the modified converted CUDA rule files.
MSBuild evaluation sequences
MsBuild evaluates properties values in sequential order or early evaluation, versus late evaluation in the old VCBuild system. Here is an example of early evaluation: if you have property a= property b; property b= property c; a, however, is not necessary equal to c, as MSBuid will not go back to reevaluate the value of a.
As a result of early evaluation, some manual modification of the converted rule files may be needed in certain circumstances. Take YASM rule for example, if your object files are not in the default $(IntDir)\%(Filename).obj defined by the rule file,, but $(IntDir)mpn\%(Filename).obj, you may need to change “Outputs” to “ObjectFileName” in the targets file for custom build rules. For example, in YASM.props, you have this defined:
At this time, the value of “ObjectFileName”, which is “$(IntDir)mpn\%(Filename).obj” is out of sync with the value of “Outputs”, which still has the value of “$(IntDir)%(FileName).obj”.
This is what you have in the targets file after conversion:
Condition="'%(YASM.Outputs)' != '' and '%(YASM.ExcludedFromBuild)' != 'true'">
<Source>@(YASM, '|')</Source>
</YASM_tlog>
</ItemGroup>
Since Outputs="@(YASM->'%(Outputs)')" are what are being passed to the linker, as a result, nothing generated from YASM will be passed. The fix is to change “Outputs” to “ObjectFileName”.
Condition="'%(YASM.ObjectFileName)' != '' and '%(YASM.ExcludedFromBuild)' != 'true'">
<Source>@(YASM, '|')</Source>
</YASM_tlog>
</ItemGroup>
Please take a look of this connect bug on the version of custom build rules that can work with YASM tools.
You can also find a version of VS2010 custom build rule here that can work with the version of YASM executable (VSYASM) that supports batching.
Escape characters
Another limitation is that quotes around files are not properly handled. You may get errors like the following:
error MSB4023: Cannot evaluate the item metadata "%(Extension)". The item metadata "%(Extension)" cannot be applied to the path ""x64\Release\add_err1_n.obj"". Illegal characters in path.
You will need to manually remove the quotes in the project file and/or .props file.
No UI support to create Custom Build Rule
One major change is that there is no more UI support in VS2010 to help you create custom build rule, although all your previous custom build rules from VS2005 and VS2008 can be converted to the VS2010 format. We are investigating ways to ease the inconvenience of the lack of UI support. The purpose of the blog is also to help you understand some of the underlying design so that you can make some small changes if needed.
I am very happy to announce that Visual Studio 2010 is now officially available! The formal announcement can be found on Soma’s blog and you can download VS 2010 from here.
Visual Studio 2010 is a great release for C++ developers. Top reasons you should look at VS2010:
1.Performance and productivity on large C++ source bases
First off, we completely revamped IntelliSense to make it more accurate and more robust on a large and complex C++ code. An IntelliSense parse of a core header file now only takes seconds instead of minutes. We also added new features that make it easier for you to work with larger sources. My favorites are: “Navigate To” which allows you to quickly navigate to any file or symbol definition from anywhere in your source code, and “C++ Squiggles” which highlights errors in your source code without having to wait for a rebuild. Moreover, with the move to MSBuild as the build engine for C++, you get more flexibility and extensibility in configuring and diagnosing your build process.
2.Windows 7 support in MFC
MFC has been extended to add support for key Windows innovations. For example, we make it easier for you to add a Windows ribbon and design its interface using the integrated Ribbon designer. We also added support for key Windows features such as multi-touch, restart manager, high DPI and Shell preview and thumbnails. It’s also a lot easier now to add support for your documents in Windows search as well as integrate with the Windows 7 taskbar. Oh, and if you’re a VC6 fan, you’ll love that we brought back the MFC Class Wizard (now with integrated search!).
3.Concurrency
VS2010 provides new libraries and tools that make it easier for C++ developers to write applications that leverage the power of multi-processors. The new Parallel Patterns Library exposes a higher level of abstraction to dealing with concurrency than raw Operating System threads. It also adds new thread-safe containers (similar to STL) that can be used in a multi-threaded application. We have also improved the debugger and profiler to make it easier for you to diagnose concurrency problems.
4.C++ language conformance
We implemented some key language and library features from the proposed C++0x standard that make it easier for you to write better and more modern C++ code. Some of my favorites are the ‘auto’ and ‘decltype’ keywords for automatic type inference as well as the support for lambda expressions (which works really well together with the parallel patterns library).
And the list goes on! If you wish to know more about the new features in VS2010 for C++ developers, check out Sumit Kumar’s latest MSDN magazine article here.
These improvements could not have been done without the overwhelming support of our customers. Thank you all for the feedback you have and continue to provide via Connect, the Forums, and this blog.
Today at 11am (PST), Charles Torre will be interviewing Kate Gregory and Richard Campbell for C9 Live at DevConnections Las Vegas to dig into improvements in the native stack in Visual Studio 2010. All native developers are encouraged to tune in and tweet questions for Kate and Richard.
Watch Channel 9 Live go to http://live.ch9.ms on April 12th at 11 AM PST (Silverlight required…)
Be a part of the conversation tweet questions and comments with @ch9live anywhere in the message and we'll see it. So, go to http://twitter.com , create an account (really easy step) and then tweet questions by prefixing @ch9live: to the question text, then click the Tweet button…
When we announced that the Visual Studio 2010 Release Candidate Is Now Available For Download, a reader, Igor, asked us to provide a table summarizing which C++0x Core Language features are implemented in VC10. So, here it is! It's derived from, but slightly modified from, GCC's tables. For example, I added "Rvalue references v2".
The difference between what I call "rvalue references v1" and "rvalue references v2" is that v1 allowed rvalue references to bind to lvalues, while v2 forbids this. N2844 "Fixing a Safety Problem with Rvalue References" describes the reasons for this change. It was recently voted into the C++0x Working Paper, and there was enough time for us to implement it in VC10. (Importantly, rvalue references v2 doesn't affect the move semantics or perfect forwarding patterns, but it does affect the implementation of std::move() and std::forward<T>(), and experts need to know about this change.)
The difference between what I call "lambdas v1.0" and "lambdas v1.1" is much less significant. After lambdas were voted into the Working Paper and implemented in VC10, N2927 "New wording for C++0x Lambdas" was additionally voted into the Working Paper, clarifying subtleties like what happens with nested lambdas. Common uses of lambdas aren't really affected, but unusual uses may be.
The "Partial" entries indicate that VC's support is either incomplete (as in the case of the C99 preprocessor, where variadic macros are implemented but mixed narrow/wide string literal concatenation isn't), or in a non-Standard form (as in the case of __func__, where __FUNCTION__ is implemented).
I don't have a similar table for the C++0x Standard Library features implemented in VC10 (preparing one based on N2870 would take a while), but slides 28 and beyond of my BoostCon 2009 presentation (attached below) contain a useful summary.
We know that build throughput for applications are a time crunch on developer productivity. We have spent some time on improving linker throughput and other areas in VS2010, and will continue to investigate improving overall build throughput in future releases.
In this blog post, we will describe a couple of options to get diagnostics for your projects using MSBuild and then taking a deeper dive into the compiler and the linker.
Using MSBuild
Using the IDE, you can enable Timing Logging by setting “Tools/Options/Projects and Solutions/VC++ Project Settings/Build Timings” = “Yes” or raise the verbosity of the build to “Diagnostics” from “Tools/Options/Project and Solutions/Build and Run/MSBuild project build output verbosity”.
Using these options, you can get performance summaries per project and also get details on where time is spent on targets and tasks. This sort of information is useful say when you are trying to figure out how long that copy task is taking to copy your files over from across folders.
1>------ Rebuild All started: Project: mfc-app, Configuration: Debug Win32 ------
1>Build started 1/12/2010 5:31:58 PM.
1>_PrepareForClean:
1> Deleting file "Debug\mfc-app.lastbuildstate".
1>InitializeBuildStatus:
1> Creating "Debug\mfc-app.unsuccessfulbuild" because "AlwaysCreate" was specified.
There are a couple of “hidden” undocumented switches that you could use to diagnose where you are spending most of your build times. /Bt and /time switches could be valuable to you if you are interested to know about where time is being spent.
We use /Bt+ and /time+ pairings for our internal throughput runs where a tool takes as input the output timings and generates a summary listing of time spent per component. This allows us to get throughput measurements for individual components. (A useful tool for someone to write and contribute to code gallery ;-) )
Note on hidden switches:
These are switches that we sometimes expose for diagnostic purposes. They are not documented and will/could change in future releases. Please use them with discretion.
Usage
·To get less verbose output, use “cl /Bt” or “link /time”
·To get more verbose output, use “cl /Bt+” or “link /time+” (Works in VS2010 only)
Using compiler switch “/Bt”
Add “/Bt” to your compiler options directly on the command line or go to project properties and add “/Bt” to Additional options in “Configuration Properties/C/C++/Command Line”. After building, the highlighted text will tell you how much time was spent in c1xx (front end compiler) and c2 (back end compiler)
1>------ Rebuild All started: Project: mfc-app, Configuration: Debug Win32 ------
1>Build started 1/13/2010 10:44:51 AM.
1>_PrepareForClean:
1> Deleting file "Debug\mfc-app.lastbuildstate".
1>InitializeBuildStatus:
1> Creating "Debug\mfc-app.unsuccessfulbuild" because "AlwaysCreate" was specified.
1>ClCompile:
1> stdafx.cpp
1> time(C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\c1xx.dll)=6.914s
1> time(C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\c2.dll)=0.064s
……
1> Generating Code...
1> time(C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\c2.dll)=0.011s
……
1> time(C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\c2.dll)=0.005s
Add “/time” to your linker options directly on the command line or go to project properties and add “/time” to Additional options in Configuration Properties->Linker->Command Line. The highlighted text will tell you how much time was spent in each pass of the linker. See more on why linker does multiple passes here
Note on LTCG: Link time code generation or LTCG is where the linker calls the back end (c2.dll) to do code generation. Thus, if you use generate LTCG builds, you may see that a lot of time is spent in the linker though it is the back end compiler that is doing all the work.
1>------ Rebuild All started: Project: mfc-app, Configuration: Debug Win32 ------
1>Build started 1/13/2010 10:47:39 AM.
1>_PrepareForClean:
1> Deleting file "Debug\mfc-app.lastbuildstate".
1>InitializeBuildStatus:
1> Creating "Debug\mfc-app.unsuccessfulbuild" because "AlwaysCreate" was specified.
Hello, I am Renin John, a Software Development Engineer in Test from the VC++ Project and Build team. I am aware that some of you prefer to do your daily work from the command prompt rather than from the IDE. I thought it would help if I put together instructions for the same using the knowledge I acquired testing Project Conversion.
In order to perform an upgrade from a prior version of Visual Studio (VC6 through VS 2008) through the command line, you could use one of the following tools:
1.devenv.exe
2.VCUpgrade.exe
They’ll come in handy even if you’re thinking of scripting the conversion process.
1.DevEnv.exe:
Like in the previous versions, you could upgrade using the devenv.exe command: just invoke it with the “/upgrade” switch. The location of devenv.exe is specified by the DevEnvDir environment variable in the VS 2010 command prompt window.
Command: a) To upgrade solution file: devenv.exe /upgrade <solution file (.sln)>; or
b) To upgrade project file: devenv.exe /upgrade <project file (.vcproj)>
This command will generate a log file named UpgradeLog.XML (UpgradeLog2.XML if UpgradeLog.XML already exists, UpgradeLog<n+1> if UpgradeLog<n> already exists, where n=2,3,…) at the end of conversion, that will contain the detailed list of errors/warnings from the conversion of the solution/project files.
Note:
i)Conversion on the command line using devenv.exe is not supported for VC6.
ii)Since the devenv.exe command is not available in the VC Express SKU, this form of conversion is not applicable here.
Hence for the above two cases, you would need to stick to the VS IDE. However, if it’s for a single project file, you have the option of using VCUpgrade.exe (described below).
2.VCUpgrade.exe
This is a new tool introduced in VS 2010. It is located in the directory specified by the VS100COMNTOOLS environment variable in the VS 2010 command prompt window.
It is going to be included in the next release of WinSDK, so the users will be able to convert their SDK based samples even if they do not have devenv.exe or rather, Visual Studio installed.
The conversion results will be displayed in the command window once the conversion is complete.
If you are re-converting your project file, invoke VCUpgrade with the “/overwrite” switch, otherwise the existing files will not be replaced.
Note: This tool has some limitations and cannot be used to convert solution files. It is recommended only for single project files: those which do not contain project to project references, and whose solution files do not contain project dependencies as this information from the solution will be lost during conversion (This is because, in VS 2010, solution dependencies are converted into project-to-project references). Use the devenv.exe tool (explained earlier) instead in these other cases, which is generally more preferred over VCUpgrade.
Reversing the upgrade:
a)If you did a solution file upgrade:
Go to the directory containing the solution and run:
del /S *.vcxproj* *.props
del *.sln UpgradeLog*.XML
move Backup\*.sln .
for /F %B in (‘dir /B Backup*’) do rd /S /Q %B
rd /S /Q _UpgradeReport_Files
b)If you did a project file upgrade:
Go to the directory containing the project file and run:
del /S *.vcxproj* *.props
del UpgradeLog*.XML
rd /S /Q _UpgradeReport_Files
You could just throw these commands into a batch file and let it take care of this for you (Replace %B above with %%B if in the batch script).
Note: If the directory containing the particular solution/project contains other solution/project files that you do not want to have deleted, please modify the commands accordingly. Also, if your project uses “.props” files located somewhere outside this directory, take care to delete those files as well.
Hope you enjoyed this blog. Do let me know if you have any questions/comments.
With the Visual Studio 2010 launch around the corner, members of the Visual C++ team will be traveling around the world to meet with you and showcase the many new features Visual Studio 2010 has to offer for C++ developers.
If we are coming to a stop near you, feel free to drop us an email and let us know. We will be delighted to meet with you and talk about all things C++ and Windows.
Today, we’ll share with you the first two sets of tour stops. Over the next few weeks, we will be sharing more information about our next stops. Stay tuned!
First Tour: Malta, Netherlands, and Belgium
Dates:
·Malta: March 26th – 27th
·Netherlands, The Hague: March 29th – 31st
·Belgium, Antwerp: April 1st – 2nd
We will be having a full day event at the Microsoft Campus in Malta on the 26th. We would love to meet with you at the event or later in the day for an informal chat over dinner or drinks.
At The Hague, we will be presenting two sessions during the Dev Days Conference:
·Modern Programming with C++0x – (March 30th 11:05 - 12:20)
·Visual C++ 2010 and MFC: The Accelerated Way towards Modern Windows 7 Applications – (March 31st 14:50 to 16:05)
We would love to see you at the conference or meet up informally outside the conference when we’re not presenting. Also, March 29th is an open day for us and we’d be happy to meet you if you’re in a nearby city. We don’t mind taking the train!
In Antwerp, we’re presenting one session at Tech Days:
·Modern Programming with C++0x – (April 1st 9:00 to 10:15)
For those attending the conference, make sure you come, watch our session and stay after it for a chat. We’d also be happy to meet with other developers in Antwerp on the 1st after our presentation. On April 2nd, we’re open to travelling to other nearby cities to meet with you.
If you’re interested in meeting with us during our first tour, drop a quick email to Tarek Madkour (tarekm [at] microsoft [dot] com) and Andy Rich (arich [at] microsoft [dot] com).
Second Tour: Romania and Bulgaria
Dates:
• Romania, Bucharest: March 26th – 29th
• Bulgaria, Sofia: March 30th – 31st
In Bucharest, we will be visiting some of the technical universities and showcasing the new Visual C++ 2010. Look for an announcement at your faculty or drop us a line if you would like to meet with us.
If you’re interested in meeting with the C++ team during our second tour, send a short email to Marian Luparu (mluparu [at] microsoft [dot] com) and Adrian Militaru (adrianmi [at] microsoft [dot] com).
Visual Studio 2010 has some enhancements that provide an easy way to get faster builds on a multiprocessor computer through parallelism. Dan Moseley a Lead Developer on MSBuild has written a blog on theC++ Build Parallelism in Visual Studio 2010.
As we wrap up Visual Studio 2010, we are starting to plan the next release of Visual C++. Our goal is to make Visual C++ a product that meets your needs. Thus we need your help.
We would like to better understand what you do. Please take a few minutes and answer the survey below. The survey is totally anonymous and the data that you provide will help us build a better product for you.
Hello, I’m Pat Brenner, a developer on the Visual C++ Libraries team. I’ve noticed some posts on various forums lamenting the loss of the ActiveX Test Container application and I wanted to address those concerns.
The ActiveX Text Container tool is still available as a sample in Visual Studio 2008 and Visual Studio 2010. It is included in the Visual C++ samples ZIP file included with Visual Studio:
·For VS2008, it’s in [Program Files]\Microsoft Visual Studio 9.0\Samples\1033\AllVCLanguageSamples.zip
·For VS2010, it’s in [Program Files]\Microsoft Visual Studio 10.0\Samples\1033\VC2010Samples.zip
The sample is named TSTCON and is in the C++\MFC\OLE\TstCon folder in the ZIP file. You can build this sample and run it to test the functionality of your ActiveX controls.
Note that there is a problem with the sample in Visual Studio 2008. After building the application, running it will give an error message because “the application configuration is incorrect”. To fix this, change the “Enable User Account Control” property on the Linker / Manifest File property page for the TCProps project to No (as in the screen shot below) and rebuild the solution. You will need to do this for all configurations and platforms that you want to run. Once you do so, the tool will run (in both Win32 and x64 configurations) without issue.
For Visual Studio 2010, the sample was converted to the new Visual C++ build system (based on MSBuild) and the problematic setting was removed during the conversion. So for Visual Studio 2010, the sample builds and runs (in both Win32 and x64 configurations) without issue.
This tool was removed from the set of tools shipped with Visual Studio 2008 for a couple of reasons:
·The code base is fairly old, and had not been maintained on a consistent basis, so there were some bugs in the tool but no resources available to fix them.
·The perception was that the tool was no longer widely used by our customers, so shipping it as a sample was thought to be sufficient.
More information about the sample can be found here.
I hope you find this information helpful. Feel free to ask any questions you have and I’ll do my best to answer them.
We changed the C++ project file format in VS2010, migrating to the new MSBuild syntax, and we changed the project file extension from vcproj to vcxproj to reflect this change. This change may impact SCC providers, depending on their design and implementation.
For example, most SCC providers based on an mssccprj.scc bindings hint file would not be able to create this file anymore because the provider only creates it for registered project extensions. Existing SCC providers will not track the new vcxproj extension without user or vendor intervention.
As a result of not being able to leverage the mssccprj.scc file for a vcxproj file, VS will instead embed the binding information into the project in two places
·vcxprojfile. This file stores SccProjectName, SccLocalPath and SccProvider as global property elements.
·suo file. This is the per solution user setting file and it is used to store the SccAuxPath property.
While this is not necessarily a bad thing, the source code control experience in VS is simpler if the SCC provider is tracking this kind of information. Let’s, examine opening from source control, and from branched locations.
Add a new project to source control, under $/Project location. Because the source control provider can’t track the new project extension (.vcxproj), it will persist the source control information in the project file. Later, create a new branch from $/Project, $/BranchedProject. Open $/BranchedProject from source control into a different location on disk. The project file will still keep embedded source control information pointing to $/Project and not $/BranchedProject. To start working against the new branch instead of the original branch, you should change source control information via FileàSource ControlàChange Source Control.
This extra step can be avoided if the source control provider is able to track the new project extension, because the mssccprj.scc hint file will contain the correct branch information from the start.
Vendor Fix
To make integration simpler for the user, when SCC providers detect integration with VS 2010, it should add the new vcxproj extension to the list of recognized VS project extensions or at least provide a way for the user to add it in the UI.
User Fix
Some SCC providers such as Microsoft Visual Source Safe already allow the tracked extensions list to be edited by a user. In VSS client this can be done via Tools à Options à File Types in Source. If you are using Source Safe, add the new project extension to the list before adding new projects to source code control or converting old controlled projects to VS2010.
The new .vcxproj.filters file and SCC
Another change made for VS2010, moved the Solution Explorer filter’s information from the project file into a separate file. This file is located on disk adjacent to the vcxproj project file, with the same name but a .vcxproj.filters extension. This change requires vendor intervention to ensure compatibility.
From the SCC perspective, this adds a new “master – special” relationship between the project and the filters file. This SCC concept is not new and refers to the behavior of special files where they remain transparent to the user, hidden in the UI but moving from workspace to depot in lockstep with their master file. The hiding behavior may vary from one SCC provider to another, but let me exemplify how Source Safe handles the “master – special” relationship.
In VSS, special files never show up in solution explorer or in the pending check-ins/checkout windows, they are listed only when they have a different source code control operation status to their master file.
For example, if you add a new header file to your source code controlled C++ project, this will generate a project change and also a filters change. Both the project and filters files will be checked out, but in the SCC pending check-in tool window only the project file will show up as changed. However, if you rename a Solution Explorer filter or move a file between filters, this change does not affect the project file and in this situation only the filters file will show up in the SCC pending check-in window.
This new relationship might impact third party SCC providers that previously didn’t have code that considered special files. A symptom of missing support is that when opening a vcxproj from source code control the project is displayed in Solution Explorer without the filter hierarchy and the .vcxproj.filters file is missing from its expected location on disk.
Project Conversion and SCC
Command Line upgrade.
Ifa VS2010 solution and project conversion are performed at the command line, conversion has no access to any SCC providers. SCC integration is typically only available from within the VS IDE. If projects are converted with commands like “devenv /upgrade” or “vcupgrade” and SCC settings are not stored inside the project, the solution will not be bound to the source code control depot when the converted solution is loaded.
This can be fixed by manually rebinding the local workspace to the SCC depot (File à Source Control à Change Source Control).
It might also be necessary to check out the solution before running the command line tools because, the command line conversion cannot request a checkout but will have modified at least the solution file locally. This can also be remedied from inside the IDE when you first load the converted solution.
If you are not using Visual Studio, but just MS command line tools and support such as the Windows SDK, this problem must be fixed up using the 3rd party SCC client software.
Visual Studio IDE upgrade
If you convert from within the VS IDE and your source control provider is either TFS or VSS, the new vcxproj projects and their filters files should be controlled automatically. VSS provides also the option of checking in the new projects and filters files, between the conversion finish and the first solution load, as you can see in the below screenshot.
Note, that in the above screenshot the filters file is not included because it has the same source control status (pending add) as its master file.
For some third party source control providers, the new project and filters files might not be automatically controlled after conversion from Orcas.Unless, the providers have implemented support for the new .vcxproj project extension and for the special-master relationship between the filters file and the project.
For those SCC providers that respond with a pending add operation to any new file dropped on disk under the enlistment root, the new project and filters files will be coincidentally controlled.
The new VS2010 project files should also be automatically controlled if the source control information was stored originally in the Orcas project files, because the conversion process would migrate those settings from .vcproj to .vcxproj, causing the new VS2010 projects to be detected as belonging to the same source control database.
Some of the source control providers that are using a mssccprj.scc hint file might still detect the new VS2010 project files before implementing support for the new extension, if their implementation takes into account the source control information of the solution. This is possible because the solution is pointing after conversion to the new .vcxproj files (instead of the old .vcproj files) and since the solution extension remained the same (.sln) the mssccprj.scc hint file works as before. Thus, all new projects belonging to the controlled solution will be automatically controlled, if the source control provider implementation is considering this scenario.
Project extension change impact on third party source control providers
The project extension change impacts third party SCC providers at conversion time in a few ways that might require Vendor intervention.
·As discussed previously, if the SCC provider uses the mssccprj.scc file and your source control provider does not know about the vcxproj extension, the source control information will now be stored in the project and .suo files.
·If the source control provider is using any special hint files based on composite of project file name (like vspscc files) those need to be renamed to take into account the new project extension.
·If the project extension is stored explicitly in any special file (like in mssccprj.scc) that needs to be replaced with the new extension.
For these scenarios the SCC provider needs to know the name of the old project. More specifically, the IVsSccManager2.RegisterSccProject method as implemented by the third party SCC provider needs to know whether the current opening project just finished a conversion operation and if so it then needs to know the name of the pre-conversion project. This can be answered by calling a new interface for VS 2010. IVsProjectUpgradeViaFactory3 in the Microsoft.VisualStudio.Shell.Interop namespace. This new interface exposes the CheckProjectUpgraded method.
[GuidAttribute(L"943CE488-176F-457B-8C88-3502C775501C")] [InterfaceTypeAttribute()] public interface class IVsProjectUpgradeViaFactory3 { ... int CheckProjectUpgraded ( [InAttribute] String^ pszFileName, [OutAttribute] bool% pbUpgradeComplete, [OutAttribute] String^% pbstrUpgradedProjectFileName ) ... }
Where:
pszFileName
The current (after upgrade) name of the project about to be opened.
pbUpgradeComplete
Returns whether the project was just successfully upgraded.
pbstrUpgradedProjectFileName
Returns the before upgrade name of the project about to be opened, if it just successfully completed a conversion, or empty string otherwise.
Thank you and let us know if you have any questions or concerns about this subject.
Andreea Isac Software Development Engineer VC Project and Build Team
XoaX Video Tutorials.
(In my Humble Opinion Excellent begiiner C++ Video Tutorials) Learn C++: Start learning C++ programming with our free C++ video tutorials. Or, watch all of these tutorials together in our C++ Beginner Playlist. The C++ tutorials are effective for beginners and great refresher tools for advanced programmers. C++ Reference section for more information and ask questions in our Forum. Once you have mastered the basics through our C++ tutorials, move on to our other subject areas. XoaX Video Tutorials also covers other computer languages.
Visual C++ Video Tutorials Watch our free Visual C++ 2008 video tutorials. Check back frequently for more. Please refer your questions to our Forum. See C++ Computer Terminology page for information on specific computer terms.
Dev-C++
: Free Integrated Development
Environment for the C/C++ Mingw compiler (included with the package).
The
ACCU is a non-profit organisation devoted to professionalism in programming
at all levels. Although primarily focussed on C and C++, we also have interests
in Java, C# and Python.
Free C/C++ Compilers and Interpreters. Looking for a free C compiler or a free C++ compiler? This page lists numerous free C and C++ compilers, cross-compilers and interpreters for a wide variety of operating systems (including embedded systems).
stdext C++ Library r170 stdext is a collection of classes I have written to augment the standard C++ library. As such, they are fashioned in the same style as the standard library's classes. Many of the classes are derivations of the iostream classes with new functionality.
Message
Passing Interface Forum. This location contains the official MPI (Message
Passing Interface) standards documents, errata, and archives of the MPI Forum.
The MPI Forum is an open group with representatives from many organizations that
define and maintain the MPI standard. MPI is a methodology of programming many
multi-processor computers. It is a method of passing data between the
Processors. MPI deals with multicore and parallelism. parallel programming.
C++ Programmers for FREE! Ask your question and get quick answers from experts. There are 2,189 online right now! We've got more than 500 tutorials and 2,000 snippets Roby's C/C++ Tutorial
Embarcadero
Developer Network (EDN), the community site for developers where you can
access, leverage and contribute valuable information and knowledge at any time.
The knowledge, systems, and membership that are EDN exist to enhance the
effectiveness of your day-to-day job performance, enrich the career of anyone
involved in systems development and management, and extend the breadth and depth
of our industry. Includes C++ Builder, Delphi, J Builder, InterBase, Rapid SQL,
etc... Using RAD, (Rapid Application Development), C++ environment and framework
designed for ultra-fast development of highly-maintainable Windows GUI
applications
Intel® Threading Building Blocks (TBB) offers a rich and complete approach to
expressing parallelism in a C++ program. It is a library that helps you take
advantage of multi-core processor performance without having to be a threading
expert. Threading Building Blocks is not just a threads-replacement library. It
represents a higher-level, task-based parallelism that abstracts platform
details and threading mechanism for performance and scalability.
Mini application server API for C++.Mini is a application server designed to be simple and have a small footprint. It has the features you need to be able to develop small web applications that you want to deploy on a machine with modest hardware. Mini is implemented as a windows service and runs under windows 2000/XP/Vista. Mini is developed by Toni Thomsson and is still under heavy development, far from
finished, especially the documentation, which for the moment is quite sparse. Still, it has been successfully used in a number of projects already. So if you are looking for something like Mini and you're not afraid of "The bleeding edge", try it out!
Hilo: Windows 7 C++ Development Walkthroughs “Hilo” is a series of articles
and sample applications that show how you can leverage the power of Windows 7,
Visual Studio 2010, and Visual C++ to build high performance, responsive rich client applications. Hilo provides both source code and the written
guidance that will help you design and develop compelling, touch-enabled Windows applications of your own.
Visual Leak Detector is a free, robust, open-source memory leak detection system for Visual C++. It's pretty easy to use. The program is used under the Visual Studio debugger, Visual Leak Detector will output a memory leak report at the end of your debugging session. The leak report includes the full call stack showing how any leaked memory blocks were allocated. Double-click on a line in the call stack to jump to that file and line in the editor window. This may help sort out any memory leaks in coding.
It's a very effective way to quickly diagnose, and fix, memory leaks in C/C++ applications.
This is the RSS search feed for Visual Studio Gallery. This feed contains notifications of new items on the Visual Studio Gallery site based on your search criteria.
Tue, 09 Feb 2010 17:43:51 -0700 - Allows users to customize the color palette used for menus, toolbars, tabs, title bars, and other environment colors.
Fri, 23 Apr 2010 14:34:45 -0700 - Team Foundation Power Tools are a set of feature add-ons aimed to enable new scenarios and solutions. Our April 2010 release adds full compatibility with the Visual Studio 2010 product releases and builds upon the success of existing tools with a few new features.
Mon, 19 Apr 2010 02:40:38 -0700 - With tangible's T4 Editor FREE EDITION you can author your own Code Generator via Text-Templates (TT-Files) with IntelliSense, Syntax-Highlighting.
Using the modeling tool you can envision and model your project and later generate from it.
Wed, 14 Apr 2010 16:58:10 -0700 - Prevent accidental Drag & Drop in Solution Explorer, Group Items, Locate In Solution, Create Code Contract, Copy/Paste References and many many others!
Thu, 18 Feb 2010 14:29:19 -0700 - A Microsoft Entity Framework project item to generate a strongly-typed ObjectContext class and entity classes with persistence ignorance in C# projects.
Mon, 08 Feb 2010 23:09:40 -0700 - Make ctrl+click perform a "Go To Definition" on the identifier under the cursor.
Also, when the ctrl key is held down, highlight identifiers that look like they have
definitions to navigate to.
Mon, 12 Oct 2009 07:53:23 -0700 - All-In-One Code Framework delineates the framework and skeleton of most Microsoft development techniques (e.g. COM, Data Access, IPC) using typical sample codes in different programming languages (e.g. Visual C#, VB.NET, Visual C++).
Tue, 13 Apr 2010 08:55:56 -0700 - CodeCompare is a totally free designed to compare code. It offers simple and familiar interface, enhanced Visual Studio editor, advanced code comparing and merging functionality.
Tue, 26 Feb 2008 02:36:52 -0700 - On-the-fly code inspections to find and instantly fix errors and code smells; 40 cross-language refactorings; ASP.NET and ASP.NET MVC development assistance; extended navigation, unit test runner; and many more productivity features.
Tue, 09 Feb 2010 23:59:51 -0700 - Provides a visualization of the types, properties, associations, and other objects present in the Entity Data Model (EDM) returned from an WCF Data Service’s metadata endpoint.
Fri, 29 Feb 2008 20:50:35 -0700 - PowerCommands 1.1 is a set of useful extensions for the Visual Studio 2008 adding additional functionality to various areas of the IDE.
Tue, 26 Feb 2008 22:32:04 -0700 - Read, write, navigate, and refactor code FAST with more than 50 productivity-boosting features for C++/C, C#, VB, ASP, JavaScript...
No Bugs: Delivering Error-Free Code in C and C++ Free Book. This book presents techniques to stop many kinds of bugs from being included in a program. It also discusses how to test programs to find bugs.
JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy for humans to
read and write. It is easy for machines to parse and generate. It is based on a
subset of the JavaScript Programming Language,
Standard ECMA-262 3rd Edition - December 1999. JSON is a text format that is
completely language independent but uses conventions that are familiar to
programmers of the C-family of languages, including C, C++,
C#,
Java/Java
Script, Perl, Python,
and many others. These properties make JSON an ideal data-interchange language.
More Java/Java Scrip
A picture is worth 1,000 lines of C++ code If a picture is worth a 1,000 words, then the computer science corollary must be "a picture is worth a 1,000 lines of C++
code." That's certainly the case for the computer science students at the University of California, San Diego who won the 2010 "paint pictures with C++ computer programming code" competition. Computer science professor Henrik Wann Jensen - winner of a 2004 Academy
Award for his work on realistic, computer-generated human skin - taught the class: CSE 168: Rendering Algorithms that finished with the friendly graphics competition.
FeatureC++ Extension of C++ specially designed to support feature-oriented programming (FOP). You can generate tailor-made software by composing C++ classes according to a feature selection!
Falcon C++ is a very useful application, designed to offer developers an easy to use and complete C++ IDE.
c Programming a web site designed to help you learn the C or C++ programming languages, and provide you with C and C++ programming language resources.
OOP School Abstraction is a central element in OOP. Four basic principles defines the object oriented approach to abstraction.
PPO School This site will
focus on good OOP practice in the tradition of Simula and BETA. The concept of object oriented programming (OOP) has been used and misused in various connections. Abstraction is a central element in OOP. Four basic principles defines the object oriented approach to abstraction. These are:
Objective-C 2.0 Essentials Free Book. Contains 34 chapters of detailed information intended to provide everything necessary to gain proficiency as an
Objective-C programmer for both
Mac OS X and
iPhone development
Message Passing Interface
Forum. This location contains the official MPI (Message Passing Interface)
standards documents, errata, and archives of the MPI Forum. The MPI Forum is an
open group with representatives from many organizations that define and maintain
the MPI standard. MPI is a methodology of programming many multi-processor
computers. It is a method of passing data between the Processors. MPI deals with
multicore and parallelism. parallel programming.
Intel® Threading
Building Blocks (TBB) offers a rich and complete approach to expressing
parallelism in a C++ program. It is a library that helps you take advantage of
multi-core processor performance without having to be a threading expert.
Threading Building Blocks is not just a threads-replacement library. It
represents a higher-level, task-based parallelism that abstracts platform
details and threading mechanism for performance and scalability.
OPERATOR DIFFERENCES The .. range operator treats certain character
ranges with care on EBCDIC machines. For example the following array will have
twenty six elements on either an EBCDIC machine or an ASCII machine. Find out
about cJ, cI, (You may see these when loading Excel characters
codes via PERL), etc...
Web Masters.Click Here Now to start making money. A Great opportunity to make some money. Receive
50% by offering your users Ton's of Keywords on
A Great Portal websites. Our Affiliate Program Pays you 50% on Level 1 of Every Sale of our
Text Link both searchable and static Text Link!
A Computer Portal. Freeware, Shareware. Download software. Computer languages and Programming code. Including PERL Scripts and Java Scripts. Webmaster Tools. Internet Marketing, Website promotion.
Hardware Help from BIOS to Windows and UNIX.
