注：C#语言发展十分迅速，而且仍然有很大的提升空间，所以现在写下的有关C#语言上的一些限制，可能过一两年就不同了，所以需要不断更新。至于C++，因为已经很久没怎么变动，所以就容易得多。
(*) 允许初始化成员变量
C#允许
C++不允许
(*) 编译器自动添加默认无参构造函数
c++：当用户实现了有参构造函数，编译器就不添加了。
c#：对于class与C++一样。但对于struct，无论用户实不实现有参构造函数，编译器都会无条件地保留一个无参构造函数。并且，不允许程序员编写自己的无参构造函数。（编译器保留的无参构造函数的行为就是分配内存，然后把所有值类型字段置0,引用类型字段置null）
(*) char和long的长度不同
C#: char 2byte, long 8byte, ulong 8byte
C++: 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++:
struct A
{
int i;
char c;
};
#pragma pack(4) // reset default
在C++里，一旦修改了pack后，就一直生效，直到再把它改回去。
C#:
struct A
{
int i;
char c;
}
在c#里pack是作为struct的属性，所以不像c++那样一旦指定后面都生效，而是要为每个struct分别指定。
(*) sizeof
C++: 不用多说了
C#:
在C#里，sizeof只能查看几种基元值类型，如int, double等等，而且只能跟类型名，不能跟变量。简直废物一个。
取而代之的是System.Runtime.InteropServices.Marshal.SizeOf，但也有个限制，就是只能查看值类型，查看所有引用类型（如string）都会使程序崩溃。
(*) 多维数组
拿动态分配的二维数组举例，C++和c#都能实现jagged矩阵(内存不连续)和整齐的矩阵(内存连续)。
先看两种语言各自实现jagged和连续内存二维数组的代码。
C++
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#
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++例子：
{
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#例子：
{
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<子类指针>(父类指针);)，如果类型不符则返回NULL
reinterpret_cast<T>(expr) 类似C的强转，据说是不应该出现的，毁掉程序可移植性的，不存在讨论价值的转换。
static_cast<T>(expr) 用于取代C的强转。值得注意的是，static_cast可将non-const转成const，即赋予const性，但去除const性则只能用const_cast。
C#
C#的强制类型转换虽然写法上和C的一样，但加了很多安全限制。有的情况下编译不过，有的情况下运行时抛出异常。
除了用括号，还有两个与转型相关的关键字：is 和 as
is举例：
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，除非用SEH
C#异常的补充：
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:
{
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#中实例函数的委托的例子：
{
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。
MyStruct[] structArray = new MyStruct[ 1 ]; // struct is created indeed, structArray[0] is an existing struct
扫一扫
450
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
