For Irrlicht, the official tutorials are pretty good. (http://irrlicht.sourceforge.net/tutorials/).

Since you will probably be using a 3D engine (like Irrlicht) rather than a low level 3D graphics API (OpenGL / DirectX) directly, you can also avoid linear algebra for a while until you have gained some familiarity with C++ (and programming in general) and are ready for some slightly more advanced graphics.

As an aside, not many developers use C# with low level OpenGL directly (via OpenTK), so why do people think that C++ developers do? The only reason I can think is that C++ developers are generally more technical so are more likely to get their hands dirty with engine programming?

C++11 has a nice set new features, you should have a look at it. unfortunately, VC++2012 still lacks in the new standard support, yes 2013 version is coming but I don't think that i will brings full c++11 support

The point made by frob about languages that are considered 'slow' is definitely a valid one. There is nothing forcing a C# programmer to use every available component from every possible feature set. This is where the performance issues come about. Not every available function was designed for a games and, no doubt, some should be avoided where speed is an issue. On the flip side of this, a sloppy coder could easily make a huge mess using a language that is considered 'fast' such as assembly, if you write inefficient code your program will be slow regardless of your choice of language. If this is a concern for you then make sure that code optimization is a focus in your research as much as anything else. Personally, I like plain old boring C for the runtime software, but this is arguing semantics, I try to only use what is common to every C-based language. Because of this, last year when I decided to rebuild my engine to work on iOS it was almost perfectly seamless, I never even bothered learning the Objective C standard and everything went fine because, as I said, I try to only use what is common to almost every language.

If you are really concerned about performance than you might consider studying as many languages as you can stand to, at least to start off with, and this way you'll start to see the pattern that is common to all, then you will naturally fall into the environment that you are best suited to. This will help you to avoid dead-ends down the road like the one that's worrying people who have been using XNA although this XNA issue doesn't sound as bad as people have been saying but this scenario is still very possible. All it takes is for one CEO and his board to bankrupt a corporation and you may find the development environment of your choice is gone the way of the dinosaur. You can future proof yourself by avoiding what is not common to all.

If you must use inefficient libraries, try to keep it out of the main game executable and only use them for pre-processing stuff like code generation, model formatting, level building and other such things. I love fstream.h and I use it constantly for code generation and diagnostics, but I'd never use it in the game itself, accessing the hard drive is at least a couple hundred times slower than the rest of the computers components.

Until you start writing in-depth physics simulations, the graphics pipeline is likely going to be the only bottleneck you face for now. Here are some optimization guides for OpenGL and DirectX. Most of these tips are common to both since the GPU is ultimately where graphics calls go. If you get this stuff right then you'll be ahead of the game.

http://www.mesa3d.org/brianp/sig97/perfopt.htm

https://www.google.ca/url?sa=t&rct=j&q=&esrc=s&source=web&cd=4&sqi=2&ved=0CEYQFjAD&url=https%3A%2F%2Fdeveloper.qualcomm.com%2Fdownload%2Fadreno200performanceoptimizationopenglestipsandtricksmarch10.pdf&ei=JATBUZ3WJeL0iQKdnYH4Cg&usg=AFQjCNFbU3Vf2mT2sf7LTAJQ3xqijdyUAA&sig2=RbjFUxJdBYsDRcSxTnWbXA&bvm=bv.47883778,d.cGE&cad=rja

http://developer.apple.com/library/ios/#documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/BestPracticesforShaders/BestPracticesforShaders.html#//apple_ref/doc/uid/TP40008793-CH7-SW3

http://developer.download.nvidia.com/GPU_Programming_Guide/GPU_Programming_Guide.pdf

http://msdn.microsoft.com/en-ca/library/windows/desktop/ee415571%28v=vs.85%29.aspx

http://www.ati.com/developer/dx9/ATI-DX9_Optimization.pdf

Here's one for AMD CPU's http://support.amd.com/us/Processor_TechDocs/47414_15h_sw_opt_guide.pdf

And one from Intel http://www.intel.com/content/dam/www/public/us/en/documents/manuals/64-ia-32-architectures-optimization-manual.pdf

Also, you mentioned issues with OpenGL compiler errors. Here is some super basic OpenGL stuff, most of it's pretty old but it still works. Each lesson has downloads for many, many compilers. The earlier ones have projects for 3 dozen different compilers.

http://nehe.gamedev.net/tutorial/lessons_01__05/22004/

The following has tons of projects for both DirectX and OpenGL

http://www.ozone3d.net/opengl_direct3d_tutorials.php

Also, if you are having hundreds of compiler errors, post them in a thread and ask for help on how to resolve them. There must be at least a few hundred people around who can easily walk you through that part. Most of the time, those huge piles of errors are really just a few errors. One missing .lib file can be responsible for dozens of those reported errors.