注：C#语言发展十分迅速，而且仍然有很大的提升空间，所以现在写下的有关C#语言上的一些限制，可能过一两年就不同了，所以需要不断更新。至于C++，因为已经很久没怎么变动，所以就容易得多。
(*) 允许初始化成员变量C#允许
C++不允许
(*) 编译器自动添加默认无参构造函数
c++：当用户实现了有参构造函数，编译器就不添加了。c#：对于class与C++一样。但对于struct，无论用户实不实现有参构造函数，编译器都会无条件地保留一个无参构造函数。并且，不允许程序员编写自己的无参构造函数。（编译器保留的无参构造函数的行为就是分配内存，然后把所有值类型字段置0,引用类型字段置null）
(*) char和long的长度不同
C#: char 2byte, long 8byte, ulong 8byteC++: char 1byte, long 4byte, ulong 4byte
(*) struct的内存分配不同
C#: 在栈上分配c++: 在哪分配由程序员说了算，只有用new的时候才在堆上分配(*) 默认参数值C++: 函数允许有默认参数值，且必须放在参数列表的最后
C#: 不支持默认参数值，可以用函数重载来实现同名函数的多种signature
(*) 条件编译
C#里的#if比较全才，能代替C++中的#if, #ifdef, #ifndef
C++：#ifdef DEBUG, #ifndef DEBUG
C#：#if DEBUG, #if !DEBUG
(*) 设置按几字节对齐(pack)
C++: #pragma pack(1) // modify struct A { int i; char c; }; #pragma pack(4) // reset default
在C++里，一旦修改了pack后，就一直生效，直到再把它改回去。
C#:
[StructLayout(LayoutKind.Sequential, Pack=1)] struct A { int i; char c; }
在c#里pack是作为struct的属性，所以不像c++那样一旦指定后面都生效，而是要为每个struct分别指定。
(*) sizeofC++: 不用多说了
C#: 在C#里，sizeof只能查看几种基元值类型，如int, double等等，而且只能跟类型名，不能跟变量。简直废物一个。取而代之的是System.Runtime.InteropServices.Marshal.SizeOf，但也有个限制，就是只能查看值类型，查看所有引用类型（如string）都会使程序崩溃。(*) 多维数组
拿动态分配的二维数组举例，C++和c#都能实现jagged矩阵(内存不连续)和整齐的矩阵(内存连续)。先看两种语言各自实现jagged和连续内存二维数组的代码。C++ int** jagged = new int*[3]; for(int i = 0; i < 3; ++i) jagged[i] = new int[4]; for(int i = 0; i < 3; ++i) for(int j = 0; j < 4; ++j) jagged[i][j] = i * 4 + j; int *matrix = new int[3 * 4]; for(int i = 0; i < 3 * 4; ++i) matrix[i] = i;
C# int[][] jagged = new int[3][]; for (int i = 0; i < jagged.Length; i++) { jagged[i] = new int[4]; } for (int i = 0; i < jagged.Length; i++) { for (int j = 0; j < jagged[i].Length; j++) { jagged[i][j] = i * 4 + j; } } int[,] matrix = new int[3, 4]; for (int i = 0; i < matrix.Length; i++) { matrix[i/4, i%4] = i; // matrix[i] = i; Error in C# but OK in C++ }
结果比较令人惊讶，在C#教材中不断强调的jagged其实在易用度上与C++几乎没有区别。反倒是连续内存的二维数组，C#要比C++易用，C#可以用matrix[row, low]来存取元素，而C++不能。因为对于连续内存的多维数组（即用[,,]形式定义的）C#有Rank的概念，而C++没有。例如上面C#代码中matrix.Rank==2。但值得注意的是，jagged.Rank==1，不是2。
(*) namespace
关于namespace其实比较杂，有些不怎么用得到，等用到了再来补充:)最常用到的就是：当命名出现冲突时，改成长一点的更加详尽的名字就可以了，无论C#还是C++C++定义别名: namespace fbz = ::foo::bar::baz;支持无名namespace，用以把作用域限制在本文件，类似static在限制作用域方面的作用C#
定义别名: using Fbz = Foo.Bar.Baz;namespace嵌套: //可以这样： namespace OuterNamespace { namespace InnerNamespace { class A { } } } //也可以这样(我更喜欢这样，因为这可以省掉很多缩进): namespace OuterNamespace.InnerNamespace { class B { } }
(*) 构造函数初始化列表
C++：既可以初始化该类本身，也可以初始化其基类的成员。
在C++中，初始化列表是必不可少的，因为以下两种情况下，它是必需的：1) const成员的初始化2) 基类没有默认构造函数（因为在创建子类之前必须先创建基类，而基类因为没有默认构造函数，需要显示调用构造函数）c#：只可以初始化其基类的成员
对于上面提到的两种情况在C#中有所不同：1) C#的const变量是静态的，必须在编译时确定值。在功能上与C++中的const相同的是readonly，但readonly在写法上允许member = value。2) 在C#中不存在“没有默认构造函”的情况，因为编译器总会给自动加上。但如果把默认构造函数显示声明为private，就无法调用了。那么就需要用base关键字：public SomeConstructor(int a, int b, int c) : base(a, b){ ...}除了上面说的基类默认构造函数是private的情况，使用base(...)初始化父类成员也会提高效率，因为如果不使用，就会调用父类默认的构造函数，父类先被构造一遍，然后在子类的构造函数内部再给父类的成员赋值，可不就多余了。
(*) 多态的enable与disable
enable多态c++：若父类方法有virtual，子类默认是override(不过C++没有override关键字，只有virtual)
c#：若父类方法有virtual，子类默认是覆盖（即new），好在会给你警告，提示你如果想多态请加上override关键字disable多态(子类向父类隐藏实现，有点像孩子瞒着家长)
C++：无法实现
C# ：用new关键字来取代override
(*) 抽象类与抽象(纯虚)函数无论纯虚还是抽象都是一个目的，即强制继承者实现。首先统一一下术语，以下用abstract来表示纯虚和抽象。
abstract函数只能出现在abstract类里，c++和C#都是这样做的，只不过实现的方式略有不同：C++：只要一个类包含了abstract函数，其所在的类就自动变成abstract。C#：如果一个类包含了abstract函数，其所在的类必须显示声明为abstract。c++例子： class A { public: virtual void foo()=0; void bar() { cout << "A::bar" << endl; } }; class B : public A { public: void foo() { cout << "B::foo" << endl; } }; int main() { B b; b.foo(); b.bar(); return 0; }
C#例子：
namespace ConsoleApplication1 { abstract class A { abstract public void foo(); public void bar() { Console.WriteLine("A.bar"); } } class B : A { override public void foo() // override不能少，否则编译器会认为B没有实现A中的foo函数而报错 { Console.WriteLine("B.foo"); } } class Program { static void Main(string[] args) { B obj = new B(); obj.foo(); obj.bar(); } } }
(*) 类型转换
c++除了兼容C的不安全的强制类型转换，它还有其他四种转换：const_cast<T>(expr) 去除const性dynamic_cast<T>(expr) 用于父类指针转换成子类指针(子类指针 = dynamic_cast<子类指针>(父类指针);)，如果类型不符则返回NULLreinterpret_cast<T>(expr) 类似C的强转，据说是不应该出现的，毁掉程序可移植性的，不存在讨论价值的转换。static_cast<T>(expr) 用于取代C的强转。值得注意的是，static_cast可将non-const转成const，即赋予const性，但去除const性则只能用const_cast。C#
C#的强制类型转换虽然写法上和C的一样，但加了很多安全限制。有的情况下编译不过，有的情况下运行时抛出异常。除了用括号，还有两个与转型相关的关键字：is 和 asis举例：if(tiger is Animal)as举例：Tiger tiger = animal as Tiger;如果animal不是一个Tiger实体，则tiger被赋值为null.(*)全局变量
即存在于任何一个类之外的变量c++允许有C#不允许有
(*) 异常
C#和C++中的异常处理仅仅通过类型而不是通过值来匹配的，否则又回到了传统的错误处理技术上去了，所以catch块的参数可以没有参数名称，只需要参数类型，除非要使用那个参数。C++
1)捕捉所有异常是：catch(...)2)支持exception specifications，即可以指出函数可能抛出异常的类型：例如：void function(int x) throw() //意思是函数实现者保证此函数不会抛出任何异常3)没有finally，除非用SEHC#异常的补充：
1.虽然异常对象看上去像局部对象，但并非创建在函数栈上，而是创建在专用的异常栈上，因此它才可以跨接多个函数而传递到上层，否则在栈清空的过程中就会被销毁。 2.函数原型中的异常说明要与实现中的异常说明一致，否则容易引起异常冲突。由于异常处理机制是在运行时有异常时才发挥作用的，因此如果函数的实现中抛出了没有在其异常说明列表中列出的异常，则编译器并不能检查出来。但是当运行时如果真的抛出了这样的异常，就会导致异常冲突。因为你没有提示函数的调用者：该函数会抛出一种没有被说明的即不期望的异常，于是异常处理机制就会检测到这个冲突并调用标准库函数unexcepted()，unexcepted()的默认行为就是调用terminate()来结束程序。实际工作中使用set_unexcepter()来预设一个回调函数。 3.Windows的SEH也是很好的异常处理方式。而且写C++程序的最高境界是尽量少用try,catch,所以……4.catch块的参数应采用常量引用传递而不是值传递，不仅可以提高效率，还可以利用对象的多态性。如果用值传递则可能出现子类向父类转换时出现的截断现象。C#
1)捕捉所有异常是：（写法比C++更简单）catch
{ ...}或
catch(Exception)2)不支持exception specifications例如：void function(int x) throw() //意思是函数实现者保证此函数不会抛出任何异常3)有finally，而且不写catch照样可以有finally。甚至using block展开成IL后就是try{}finally{}的结构。C#异常的补充：
1.Exception类的成员非常多，其中两个我认为比较有用，一个是StackTrace属性。另一个是Data属性（本质上是一个IDictionary），利用Data属性可以任意添加自定义的新成员，例如ex.Data.Add("TimeStamp", String.Format("{0}", DateTime.Now));2.自定义异常的最佳实践
一般的应用程序异常应该继承自ApplicationException，而不是SystemException。这样可以很好地区分哪些异常是应用程序产生的，哪些是.NET底层类库产生的。所以一般简单的自定义的异常都这么写：
public class EngineIsDeadException : ApplicationException{ public EngineIsDeadException() { } public EngineIsDeadException(string message) : base(message) { }}.NET最佳实践的自定义异常比较复杂，当你在VS里写下Except+Tab产生出代码片段就知道了。
(*) 回调
C++：和C一样使用函数指针，静态方法还算方便，实例的方法比较麻烦。下面是实例方法指针的sample code: class A { public: void foo() { cout << "foo" << endl; } void bar() { cout << "bar" << endl; } }; typedef void (A::*f)(void); void func(f fp) { A a; (a.*fp)(); } int main() { f fp = &A::foo; func(fp); fp = &A::bar; func(fp); return 0; }
从上面代码可以看出，在C++里实例的函数指针必须加上实例名做前缀。虽然号称是指向实例成员的函数指针，但也仅仅是个指针而已(vtbl中的偏移量)，它对实例的状态一无所知。而C#就不同了。
C#：使用委托：对实例方法支持得更好，支持异步。
举一个C#中实例函数的委托的例子：
class MyClass { private string name; public MyClass(string name) { this.name = name; } public void DisplayName() { Console.WriteLine("{0}", name); } } class Program { // 委托其实就相当于一个类型。这里，类型的名字叫SimpleDelegate public delegate void SimpleDelegate(); static void Main() { MyClass a = new MyClass("A"); MyClass b = new MyClass("B"); // 用实例方法DisplayName初始化 SimpleDelegate d = new SimpleDelegate(a.DisplayName); d(); d = new SimpleDelegate(b.DisplayName); d(); } }
(*) 数组的创建
C++无论在堆上还是栈上创建数组，都是实实在在地分配内存，并对数组中的每一个元素调用构造函数。
C#则不一样。对值类型它分配内存并初始化成0，对引用类型则只给每个对象分配一个引用，并初始化成null。
MyClass[] classArray = new MyClass[1]; // No instance is created, classArray[0] is null MyStruct[] structArray = new MyStruct[1]; // struct is created indeed, structArray[0] is an existing struct