C#与C++的几个不同之处知识点

1.索引器

索引器是C#自创的内容，这是C++当中没有的内容，所以做一次笔记.

索引器是用于书写一个可以通过使用[]想数组一样直接访问集合元素的方法。我们只需要指定待访问实例或元素的索引。索引器的语法和类属性语法相同，除了接受作为元素索引的输入参数外。

class SampleCollection<T>
{
    // 声明一个数组来存储数据元素。
    private T[] arr = new T[100];

    // 定义索引器,它允许客户机代码 　　
    / /类实例上使用[]符号本身。 　　
    / /下面的代码主要(参见第2行。)         
    public T this[int i]
    {
        get
        {
            //这个索引器非常简单,仅仅返回或设置 　　
            //数组从内部相应的元素。
            return arr[i];
        }
        set
        {
            arr[i] = value;
        }
    }
}

//program类显示了客户端代码使用索引器。
class Program
{
    static void Main(string[] args)
    {
        // 声明SampleCollection类型的一个实例。
        SampleCollection<string> stringCollection = new SampleCollection<string>();

        // 使用[]符号的类型。
        stringCollection[0] = "Hello, World";
        System.Console.WriteLine(stringCollection[0]);
    }
}                

 

 2.拆箱与装箱

装箱：所谓装箱是将一个原始类型或基础类型对象赋给一个object对象，object是C#基类，所有类都继承自object类

拆箱：反之，拆箱是将一个事先装箱过的object对象强制转换为目标对象。

例如：

class Test
{
    static void Main()
      {
             int mInt;
             object obj=mInt;//装箱
             int myInt=(int) obj;//拆箱               
          }
}    

3.参数的按值传递与按引用传递

在C#当中，按值传递与C++是一样的，这里不做介绍了；主要说一下按引用传递。

C#使用关键字ref指定引用参数，在形参中使用ref的同时，在实参中也要用ref，否则将出现编译错误，另外你不能将一个没用初始化的对象按引用传递给函数。

例如：

class TestRef
{
      int a=5;
      myMethod(ref a);//use func by ref
       .........
       void myMethod(ref int a)
        {
               //function block
        }
}

4.输出参数

输出参数只是从函数返回值的参数，输入值不要求。C#使用关键词out表示输出参数。

例如：

class TestOut
{
    int val;
    getNodeValue(val);
    ..........
    bool getNodeValue(out int val)
    {
        val = value;
         return true;
    }    

5.可变数量的参数和数组

C#中的数组使用关键词param进行传递,一个数组类型的参数必须总是函数最右边的参数.可以传递任意数量的的元素作为数组类型的参数。

例如：

class TestArray

{

　　void func(param int []array)

　　{

　　　　print(array.length);
　　}

　　func(1);//输出1

　　func();//输出0

　　func(7,9,4);//输出3

　　func(new int[]array {4,6,7,3,5});//输出5

　　int []array2=new int[]{4,5,6,1,2,3};

　　func(array2);//输出6

}

6.运算符与表达式

 is关键字:

is关键字的作用是检查目标对象与给定对象是否兼容；如果所提供的表达式非空，并且所提供的对象可以强制转换为所提供的类型而不会导致引发异常，则 is 表达式的计算结果将是 true。

 例如：

class test1{}
class test2{}
class test3: test2{}

class isTest
{
    test1 t1;
    test2 t2;
    static void Test(object obj)
    {
        if(obj is t1)
        {
            print("obj is test1 classes");
            t1 = (test1)obj;
        }
        else if(obj is t2)
        {
            print("obj is test2 classes);
            t2 = (test2)obj;
         }
            else
            {
                    print("obj not is test1 and test2");
            }    
     }
   static void Main()
    {
            test1 T1=new test1();
            test2 T2 = new test2();
            test3 T3 = new test3();
            
            test(T1);
            test(T2);
            test(T3);
            test("my test content");
    }
}

as关键字：

 as关键字类似于C++强制类型转换，但是如果强制转换不成功，as将返回null而不引发异常。

例如：

namespace MyFirstApp
{
    class Base
    {
        public override string ToString()
        {
            return "base";
        }
    }
    class Device : Base
    {
        public delegate void GetVisiter(string name);
    }
    class Program
    {        
        static int Main()
        {
            Device de = new Device();
            Base b = de as Base;
            if(de != null)
            {
                System.Console.WriteLine(de.ToString());
            }
            return 0;
        }
    }
}

表达式：

expression as type

和下面的代码是一样的效果，说明as关键字是通过is来实现的

expression is type ? (type)expression : (type)null

 sealed 关键词

被sealed修饰的类不能被实例化

7.接口类interface

在C#当中不引许多继承，多继承应该考虑把基类声明为interface，并且在interface声明封装的类中，不引许函数的实现，只能写出声明，就像C++的头文件，函数的实现留给派生类或结构去实现。

例如：

//interface
interface Equatable<T>
{
        bool Equals(T obj);//只能写出函数声明
}


//
public class TestEquals : Equatable<TestEquatable>
{
    public string Make { get; set; }
    public string Module { get; set; }
    public string Year { get; set; }

    public bool Equals(TestEquals te)//实现基类当中的Equals函数
    {
            if(this.Make==te.Make &&
                this.Module==te.Module &&
                this.Year==te.Year)
        {
                return true;
        }
            else
        {
            return flase
        }
}

注意：

接口具有下列属性：

• 接口与抽象基类。 实现接口的任何类或结构必须实现其所有成员的链接。

• 接口不能直接实例化。 其成员通过实现接口的任何类或结构实现。

• 接口可以包含事件、索引器、方法和属性。

• 接口不包含方法的实现。

• 类或结构可以实现多个接口。 类可以继承基类并实现一个或多个接口

转载于:https://www.cnblogs.com/Leekin/p/5813087.html