vector-like wrapper for IList

[Christian Schmidt]

Hi all,
I'm trying to implement a std::vector-like wrapper for IList.
The hard part seems to be operator[], because it returns an unmanaged
reference. Probably I have to use pin_ptr to achieve this, but I don't
know how.
Can anybody help?

Thanks,
Christian
template <typename T>
class IListWrapper {
public:
IListWrapper(IL ist<T>^ _list) : list(_list) { }
T& operator[](unsigned i) { return list->default[i]; }
const T& operator[](unsigned i) { return list->default[i]; }
unsigned size() const { return list->Count; }
void push_back(const ItemType& item) { list->Add(item); }
protected:
gcroot<IList<It emType>^list;
};

void main() {
IListWrapper<do ublelist(gcnew List<double>(10 ));
list[3] = 7.5;
}

[Carl Daniel [VC++ MVP]]

Christian Schmidt wrote:

Hi all,
I'm trying to implement a std::vector-like wrapper for IList.
The hard part seems to be operator[], because it returns an unmanaged
reference. Probably I have to use pin_ptr to achieve this, but I don't
know how.
Can anybody help?

You can't do it like that. pin_ptr by design must be a local
(stack-allocated) variable, which means that any pin_ptr your operator[]
declares will go out of scope, unpinning the value before the operator
returns.

Unfortunately, I think you're probably going to have to return some kind of
proxy object (a la vector<bool>) to simulate the std::vector interface on an
IList<T>. The proxy object would have an operator T() and an
operator=(const T&) so it can stand-in for a 'T' in many contexts - but not
all. The proxy object would hold onto a T^ and perform the native <-->
managed conversions in the two conversion functions.

-cd

[Christian Schmidt]

Hi Carl,
thanks for your answer.

Carl Daniel [VC++ MVP] wrote:

>I'm trying to implement a std::vector-like wrapper for IList.
The hard part seems to be operator[], because it returns an unmanaged
reference. Probably I have to use pin_ptr to achieve this, but I don't
know how.
Can anybody help?

You can't do it like that. pin_ptr by design must be a local
(stack-allocated) variable, which means that any pin_ptr your operator[]
declares will go out of scope, unpinning the value before the operator
returns.

So I would need to pin the list in the constructor. Is this a problem?
How would I proceed?

Unfortunately, I think you're probably going to have to return some kind of
proxy object (a la vector<bool>) to simulate the std::vector interface on an
IList<T>. The proxy object would have an operator T() and an
operator=(const T&) so it can stand-in for a 'T' in many contexts - but not
all. The proxy object would hold onto a T^ and perform the native <-->
managed conversions in the two conversion functions.

Will this work for value types in the IList, too? Or do I have to use
the setter of the IList?
Is this a correct implementation of the Proxy?

template <typename T>
class ReferenceWrappe r {
public:
ReferenceWrappe r(T^ _me) : me (_me) { }
ReferenceWrappe r<Toperator=(co nst T& other) {
me = other;
return *this;
}
operator T() { return *(T^) me; }
protected:
gcroot<T^me;
};

[Carl Daniel [VC++ MVP]]

Christian Schmidt wrote:

Hi Carl,
thanks for your answer.

Carl Daniel [VC++ MVP] wrote:

>>I'm trying to implement a std::vector-like wrapper for IList.
The hard part seems to be operator[], because it returns an
unmanaged reference. Probably I have to use pin_ptr to achieve
this, but I don't know how.
Can anybody help?

You can't do it like that. pin_ptr by design must be a local
(stack-allocated) variable, which means that any pin_ptr your
operator[] declares will go out of scope, unpinning the value before
the operator returns.

So I would need to pin the list in the constructor. Is this a problem?
How would I proceed?

No, you can't have a pin_ptr as a member variable. You have to pin it,
reference it, and un-pin it in each invocation of operator T() or operator=
(const T&).

>

>Unfortunatel y, I think you're probably going to have to return some
kind of proxy object (a la vector<bool>) to simulate the std::vector
interface on an IList<T>. The proxy object would have an operator
T() and an operator=(const T&) so it can stand-in for a 'T' in many
contexts - but not all. The proxy object would hold onto a T^ and
perform the native <--managed conversions in the two conversion
functions.

Will this work for value types in the IList, too? Or do I have to use
the setter of the IList?
Is this a correct implementation of the Proxy?

Something like that, yes.

-cd

[Ben Voigt [C++ MVP]]

"Christian Schmidt" <no**@locom.dew rote in message
news:uy******** ******@TK2MSFTN GP03.phx.gbl...

Hi Carl,
thanks for your answer.

Carl Daniel [VC++ MVP] wrote:

>>I'm trying to implement a std::vector-like wrapper for IList.
The hard part seems to be operator[], because it returns an unmanaged
reference. Probably I have to use pin_ptr to achieve this, but I don't
know how.
Can anybody help?

You can't do it like that. pin_ptr by design must be a local
(stack-allocated) variable, which means that any pin_ptr your operator[]
declares will go out of scope, unpinning the value before the operator
returns.

So I would need to pin the list in the constructor. Is this a problem? How
would I proceed?

>Unfortunatel y, I think you're probably going to have to return some kind
of proxy object (a la vector<bool>) to simulate the std::vector interface
on an IList<T>. The proxy object would have an operator T() and an
operator=(cons t T&) so it can stand-in for a 'T' in many contexts - but
not all. The proxy object would hold onto a T^ and perform the native
<--managed conversions in the two conversion functions.

Will this work for value types in the IList, too? Or do I have to use the
setter of the IList?

To implement operator[] assignment, yes, you'll need to use the IList
setter.

Either your caller needs to be managed type aware, in which case you don't
need pinning pointers at all, or you have a managed collection of primitive
types. Can you fill in some of the blanks here?

Maybe all you are looking for is the T^% tracking reference syntax.

>

Is this a correct implementation of the Proxy?

template <typename T>
class ReferenceWrappe r {
public:
ReferenceWrappe r(T^ _me) : me (_me) { }
ReferenceWrappe r<Toperator=(co nst T& other) {

It's customary to return a reference.

me = other;

Need to dereference me here, ala (*me = other), or else reassign me to a new
valid handle, which other isn't.

return *this;
}
operator T() { return *(T^) me; }

The compiler should choke on that if T is a class type. If it isn't, why
are you boxing it (T^ to a value type incurs boxing).

protected:
gcroot<T^me;
};

Look up interior_ptr<T> .