.net C+中的Collections:：Generic:：Dictionary是否有与map:：key_type等价的类型+/CLI？ 在一个C++模板函数中，以STD::MAP类型作为模板，我可以使用T::KyyType和t::ValueEyType创建密钥和值。 如果T是Collections:：Generic:：Dictionary，则C++/CLI中是否有等效项

我什么也看不见

我想做以下几点：

   template<typename T> // T is a Collections::Generic::Dictionary
   T^ Copy(T^ src)
   {
      T^ dst;
      Threading::Monitor::Enter(src);
      try
      {
         dst = gcnew T(src);
         for each (T::key_type^ key in src->Keys) // no such type!
         {
            T::value_type^ srcValue = dynamic_cast<T::value_type^>(src[key]); // no such type!
            if (srcValue)
            {
               T::value_type^ copiedValue = gcnew T::value_type(/*some values common to my value types here*/); // no such type!
               copiedValue->Clone(*srcValue);
               dst->Add(key, copiedValue);
            }
         }
      }
      finally
      {
         Threading::Monitor::Exit(src);
      }
      return dst;
   }

template//T是一个集合：：泛型：：字典
T^Copy（T^src）
{
T^dst；
线程：：监视器：：输入（src）；
尝试
{
dst=GCT（src）；
对于每个（T:：key\u type^key in src->Keys）//没有这样的类型！
{
T:：value_type ^srcValue=dynamic_cast（src[key]）；//没有这样的类型！
if（src值）
{
T:：value_type ^copiedValue=gcnew T:：value_type（/*此处为我的值类型所共有的一些值*/）；//没有这样的类型！
复制值->克隆（*srcValue）；
dst->Add（键，复制值）；
}
}
}
最后
{
线程：：监视器：：退出（src）；
}
返回dst；
}

可能有更好的方法，但是：从Visual Studio 2010开始，C++/CLI编译器支持许多新的C++1x功能，包括

decltype

和

auto

。使用这些，您可以执行以下操作：

typedef decltype(src->Keys->GetEnumerator().Current) key_type;
typedef decltype(src->Values->GetEnumerator().Current) value_type;

或

---

对于旧版本，您可以尝试部分模板专门化：

#include "stdafx.h"

using namespace System;

ref class Val
{
public:
    void CloneFrom(Val^) {}
};

template<typename D> struct dictionary_traits;
template<typename K, typename V> struct dictionary_traits<Collections::Generic::Dictionary<K, V>>
{
    typedef K key_type;
    typedef V value_type;
};

template<typename T> struct strip_managed;
template<typename T> struct strip_managed<T^>
{
    typedef T type;
};

template<typename T> // T is a Collections::Generic::Dictionary
T^ Copy(T^ src)
{
    typedef typename dictionary_traits<T>::key_type key_type;
    typedef typename dictionary_traits<T>::value_type value_type;

    T^ dst;
    Threading::Monitor::Enter(src);
    try
    {
        dst = gcnew T(src);
        for each (key_type key in src->Keys)
        {
            value_type srcValue = src[key];
            if (srcValue)
            {
                value_type copiedValue = gcnew typename strip_managed<value_type>::type();
                copiedValue->CloneFrom(srcValue);
                dst->Add(key, copiedValue);
            }
        }
    }
    finally
    {
        Threading::Monitor::Exit(src);
    }
    return dst;
}

int main(array<System::String ^> ^args)
{
    auto dict = gcnew Collections::Generic::Dictionary<Object^, Val^>();
    Copy(dict);
    return 0;
}

#包括“stdafx.h”
使用名称空间系统；
参考等级Val
{
公众：
无效克隆自（Val^{}
};
模板结构字典；
模板结构字典
{
typedef K key_type；
类型定义V值_类型；
};
管理的模板结构条带；
模板结构条带\u管理
{
T型；
};
模板//T是一个集合：：泛型：：字典
T^Copy（T^src）
{
typedef typename dictionary_traits:：key_type key_type；
typedef typename dictionary_traits:：value_type value_type；
T^dst；
线程：：监视器：：输入（src）；
尝试
{
dst=GCT（src）；
对于每个键（在src中键入键->键）
{
value_type srcValue=src[key]；
if（src值）
{
value_type copiedValue=gcnew typename strip_managed:：type（）；
copiedValue->CloneFrom（srcValue）；
dst->Add（键，复制值）；
}
}
}
最后
{
线程：：监视器：：退出（src）；
}
返回dst；
}
int main（数组^args）
{
auto dict=gcnew Collections:：Generic:：Dictionary（）；
副本（dict）；
返回0；
}

可能有更好的方法，但是：从Visual Studio 2010开始，C++/CLI编译器支持许多新的C++1x功能，包括

decltype

和

auto

。使用这些，您可以执行以下操作：

typedef decltype(src->Keys->GetEnumerator().Current) key_type;
typedef decltype(src->Values->GetEnumerator().Current) value_type;

或

---

对于旧版本，您可以尝试部分模板专门化：

#include "stdafx.h"

using namespace System;

ref class Val
{
public:
    void CloneFrom(Val^) {}
};

template<typename D> struct dictionary_traits;
template<typename K, typename V> struct dictionary_traits<Collections::Generic::Dictionary<K, V>>
{
    typedef K key_type;
    typedef V value_type;
};

template<typename T> struct strip_managed;
template<typename T> struct strip_managed<T^>
{
    typedef T type;
};

template<typename T> // T is a Collections::Generic::Dictionary
T^ Copy(T^ src)
{
    typedef typename dictionary_traits<T>::key_type key_type;
    typedef typename dictionary_traits<T>::value_type value_type;

    T^ dst;
    Threading::Monitor::Enter(src);
    try
    {
        dst = gcnew T(src);
        for each (key_type key in src->Keys)
        {
            value_type srcValue = src[key];
            if (srcValue)
            {
                value_type copiedValue = gcnew typename strip_managed<value_type>::type();
                copiedValue->CloneFrom(srcValue);
                dst->Add(key, copiedValue);
            }
        }
    }
    finally
    {
        Threading::Monitor::Exit(src);
    }
    return dst;
}

int main(array<System::String ^> ^args)
{
    auto dict = gcnew Collections::Generic::Dictionary<Object^, Val^>();
    Copy(dict);
    return 0;
}

#包括“stdafx.h”
使用名称空间系统；
参考等级Val
{
公众：
无效克隆自（Val^{}
};
模板结构字典；
模板结构字典
{
typedef K key_type；
类型定义V值_类型；
};
管理的模板结构条带；
模板结构条带\u管理
{
T型；
};
模板//T是一个集合：：泛型：：字典
T^Copy（T^src）
{
typedef typename dictionary_traits:：key_type key_type；
typedef typename dictionary_traits:：value_type value_type；
T^dst；
线程：：监视器：：输入（src）；
尝试
{
dst=GCT（src）；
对于每个键（在src中键入键->键）
{
value_type srcValue=src[key]；
if（src值）
{
value_type copiedValue=gcnew typename strip_managed:：type（）；
copiedValue->CloneFrom（srcValue）；
dst->Add（键，复制值）；
}
}
}
最后
{
线程：：监视器：：退出（src）；
}
返回dst；
}
int main（数组^args）
{
auto dict=gcnew Collections:：Generic:：Dictionary（）；
副本（dict）；
返回0；
}

字典是泛型类，而不是模板。在罗马时，像罗马人一样行事，并编写一个通用方法：

ref class Example {
public:
    generic<typename K, typename V>
    Dictionary<K, V>^ Copy(IDictionary<K, V>^ src) {
        auto cpy = gcnew Dictionary <K, V> ;
        for each (K key in src->Keys) cpy->Add(key, src[key]);
        return cpy;
    }
};

ref类示例{
公众：
通用的
词典^副本（IDictionary^src）{
自动cpy=gcnewdictionary；
对于每个（src中的K键->键）cpy->添加（键，src[key]）；
返回cpy；
}
};

请注意，这将创建字典中值的浅拷贝。如果V是一个值类型，这很好，如果它是一个引用类型，可能就不那么好了。尽管由于垃圾收集器，在.NET中它的必要性要小得多。如果需要，那么请记住，没有深入复制引用类型对象的通用方法，除非您自己显式地实现它。例如，这需要一个由V类型实现的idepclone接口。例如：

generic<typename T>
interface class IDeepClone {
    T Copy();
};

通用
接口类IDeepClone{
T复制（）；
};

您可以使用where关键字通过一个约束告诉编译器：

ref类示例{
公众：
通用的
其中V:IDeepClone
词典^副本（IDictionary^src）{
自动cpy=gcnewdictionary；
对于每个（src->Keys中的K键）cpy->Add（key，src[key]->Copy（））；
返回cpy；
}
};

字典是泛型类，而不是模板。在罗马时，像罗马人一样行事，并编写一个通用方法：

ref class Example {
public:
    generic<typename K, typename V>
    Dictionary<K, V>^ Copy(IDictionary<K, V>^ src) {
        auto cpy = gcnew Dictionary <K, V> ;
        for each (K key in src->Keys) cpy->Add(key, src[key]);
        return cpy;
    }
};

ref类示例{
公众：
通用的
词典^副本（IDictionary^src）{
自动cpy=gcnewdictionary；
对于每个（src中的K键->键）cpy->添加（键，src[key]）；
返回cpy；
}
};

请注意，这将创建字典中值的浅拷贝。如果V是一个值类型，这很好，如果它是一个引用类型，可能就不那么好了。尽管由于垃圾收集器，在.NET中它的必要性要小得多。如果需要，那么请记住，没有深入复制引用类型对象的通用方法，除非您自己显式地实现它。这需要