220 40974 <467a0621-ed78-4a96-b8f2-3485e059d840@isocpp.org> article Path: news.gmane.org!.POSTED!not-for-mail From: Itaj Sherman Newsgroups: gmane.comp.lang.c++.isocpp.proposals Subject: Re: Pointer to pointer representation Date: Sun, 11 Nov 2018 18:41:04 -0800 (PST) Lines: 449 Approved: news@gmane.org Message-ID: <467a0621-ed78-4a96-b8f2-3485e059d840@isocpp.org> References: Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: blaine.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_1658_1845307955.1541990464656" X-Trace: blaine.gmane.org 1541990341 25505 195.159.176.226 (12 Nov 2018 02:39:01 GMT) X-Complaints-To: usenet@blaine.gmane.org NNTP-Posting-Date: Mon, 12 Nov 2018 02:39:01 +0000 (UTC) Cc: tecoberg@gmail.com To: ISO C++ Standard - Future Proposals Original-X-From: std-proposals+bncBCFJBV63SUOBBQOQUPPQKGQE6CSUFRI@isocpp.org Mon Nov 12 03:38:56 2018 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-yw1-f72.google.com ([209.85.161.72]) by blaine.gmane.org with esmtp (Exim 4.84_2) (envelope-from ) id 1gM27s-0006Vd-Cc for gclcip-std-proposals@m.gmane.org; Mon, 12 Nov 2018 03:38:56 +0100 Original-Received: by mail-yw1-f72.google.com with SMTP id e62-v6sf7237089ywf.21 for ; Sun, 11 Nov 2018 18:41:07 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=isocpp-org.20150623.gappssmtp.com; s=20150623; h=date:from:to:cc:message-id:in-reply-to:references:subject :mime-version:x-original-sender:reply-to:precedence:mailing-list :list-id:list-post:list-help:list-archive:list-subscribe :list-unsubscribe; bh=V6wPubtzCqDZTE/b+B9+Ssl5xcpq/7qn8fN+ObJkLKs=; b=m6Py2fbvu3KF9EjzGDBUsB7AvZbv88vOIRjaQfjdDuhU9cc4HMr+mqq7QriLcYv+Rk k4k6hDRWEuUwjdWQMK8J+5Mipzr7wZ746JOek1JeudnnJHd6N4gVXg3Up70ovo2+O5FE cITSi6xgejvdWU4HX9Rh2v6bzE+6G8TZo4lePbN88N7pGu0qjm5PD8lIlRexoNXzb3OS zTBEcB4nlLTtPZ2dZHe9/I18KZ8mxMtlEgMgSGiKdP8z0OlNhR9yK69Osfw79jUcR+74 7kYyEe+Tujnd1hCB11pRTvcyEkyE6jOmszyYSS1Vy3j9hE7ZxaO+UX2i/S5cXrkwptqO FaTQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=date:from:to:cc:message-id:in-reply-to:references:subject :mime-version:x-original-sender:reply-to:precedence:mailing-list :list-id:list-post:list-help:list-archive:list-subscribe :list-unsubscribe; bh=V6wPubtzCqDZTE/b+B9+Ssl5xcpq/7qn8fN+ObJkLKs=; b=NSq6pTiJ85MLvimxYANk8GZkQRe9vaYpBQz8Ko2+L3GQ8ebkJIojo0JFofDFzZMSFX uqSJjv+pFg7cXwRD4IqE+sJYWgByH3UOmX9qfWt+eBY6BVlkorCFmRHT2i837DfapB4D JERBrUS7ZuTxwiBLQk3ZkRysFjT5UISwj7h/6KW+FnNG1WEuznzpdKNdr5yt6dWgpvIG XSeHeNOOWgyvEawE37NrCQAjXhtd97PDMr5xMxr9VjzqF2eSEy/dogYrTaRdDihf7fb1 3kXTRtYXLeKEkk7NtZ+Nnkkk7CvWTDyL7KnrMiQMzMKzov1HOHQjUBwRYDO+BnxarBTK haWA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:message-id:in-reply-to :references:subject:mime-version:x-original-sender:reply-to :precedence:mailing-list:list-id:x-spam-checked-in-group:list-post :list-help:list-archive:list-subscribe:list-unsubscribe; bh=V6wPubtzCqDZTE/b+B9+Ssl5xcpq/7qn8fN+ObJkLKs=; b=eXBN5fSRSrwGuMWfIWzyQRs6syUS6bFCvk0cZvVl3JquIGjF1L2y/HlUVIj9n9mNMn hL86ECV8XJCpX9h8y0sVRu7/w4AwxHzsA3O6hJp2H91vr7TlhP0a39Op2WWmi4Wyi6PB zJuI8fF5QQxO9M8rsfrw/bnYFQjihsUWVN7jimEzR1D0mXB2MLaiRnIK03zG9sVmY9Ku yW07HHblGMjbkBwSzzxDs8Z6JEibxarrPEZvEcpr4jGOHk5VowSJ0eQAP3oklcLsJeOA ZhXr975oy/uWw/VQECTOT0GSwqXAq8hW8cSzEGYXN3Wj5aAAeWrGnPQj6eBvA0Oje6So Kv0w== X-Gm-Message-State: AGRZ1gLKltW/jafR5jtPADk1rsOz93RvKRYu0tiw/xXeMk4Ln/i9pBb4 U8r+cq89gb6YChnbbhbRwcgg+w== X-Google-Smtp-Source: AJdET5eY9DeVI0Ixve1/7if1eclXOxCSBHdV4QiDPKxFpZT/315UffFDDekbm+e90tJiMA8UC5EpRw== X-Received: by 2002:a81:58c2:: with SMTP id m185-v6mr9193975ywb.11.1541990466414; Sun, 11 Nov 2018 18:41:06 -0800 (PST) X-BeenThere: std-proposals@isocpp.org Original-Received: by 2002:a25:180b:: with SMTP id 11-v6ls126389yby.11.gmail; Sun, 11 Nov 2018 18:41:05 -0800 (PST) X-Received: by 2002:a25:afcd:: with SMTP id d13-v6mr183494ybj.2.1541990465215; Sun, 11 Nov 2018 18:41:05 -0800 (PST) In-Reply-To: X-Original-Sender: itajsherman@gmail.com Precedence: list Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org List-ID: X-Spam-Checked-In-Group: std-proposals@isocpp.org X-Google-Group-Id: 399137483710 List-Post: , List-Help: , List-Archive: List-Subscribe: , List-Unsubscribe: , Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:40974 Archived-At: ------=_Part_1658_1845307955.1541990464656 Content-Type: multipart/alternative; boundary="----=_Part_1659_1014403419.1541990464657" ------=_Part_1659_1014403419.1541990464657 Content-Type: text/plain; charset="UTF-8" Suppose you had a template function recursive_arrow_func(p) that recursively applies operator-> on p, as p.operator->().operator->().operator->() until it returns a pointer to an object type that has no operator-> Then you could use it as: recursive_arrow_func(p)->FuncMember(); Even if p was a pointer to pointer to pointer. you could use this function to create one of several possible syntaxes, using a keyword, say "arrows": arrows(p)->FuncMember(); arrows[p]->FuncMember(); arrows{p}->FuncMember(); arrows--(p)->FuncMember(); arrows--[p]->FuncMember(); arrows(p).FuncMember(); arrows[p].FuncMember(); arrows{p}.FuncMember(); arrows--(p).FuncMember(); arrows--[p].FuncMember(); It could even do stuff like this: template< typename T > class my_ptr { private: T* m; public: my_ptr(T* r) : m(r) {} public: T* operator->() const { return m; } T& operator*() const { return *m; } }; void g_test_recursive_arrow() { using element_t = std::pair< double, double >; element_t a = { 1.5, 2.5 }; my_ptr< element_t > m = &a; assert(a.first == arrows(m)->first); my_ptr< my_ptr< element_t > > mm = &m; assert(a.first == arrows(mm)->first); my_ptr< my_ptr< my_ptr< element_t > > > mmm = &mm; assert(a.first == arrows(mmm)->first); element_t* p = &a; assert(a.first == arrows(p)->first); element_t** pp = &p; assert(a.first == arrows(pp)->first); element_t*** ppp = &pp; assert(a.first == arrows(ppp)->first); my_ptr< element_t >* pm = &m; assert(a.first == arrows(pm)->first); my_ptr< element_t* > mp = &p; assert(a.first == arrows(mp)->first); my_ptr< my_ptr< element_t >* > mpm = ± assert(a.first == arrows(mpm)->first); my_ptr< element_t* >* pmp = ∓ assert(a.first == arrows(pmp)->first); } Here's a possible implementation. I needed a traits 'has_arrow' but I couldn't find it in boost, so I used boost::has_dereference. So classes with operator-> must has operator* to be usable. namespace recursive_dereferencing { namespace detail { template class has_arrow { public: static const bool value = boost::has_dereference::value; }; template< typename T > class recursive_arrow_result_impl; template< typename T, bool > class recursive_arrow_result_impl2 { public: using type = typename recursive_arrow_result_impl< std::invoke_result_t< decltype(&(T::operator->)), T > >::type; }; template< typename T > class recursive_arrow_result_impl2< T, false > { public: using type = T & ; }; template< typename T > class recursive_arrow_result_impl { public: using type = typename recursive_arrow_result_impl2::value >::type; }; template< typename T > class recursive_arrow_result_impl { public: using type = typename recursive_arrow_result_impl< T >::type; }; template< typename T > class recursive_arrow_result_impl { public: using type = typename recursive_arrow_result_impl< T >::type; }; template< typename T > class recursive_arrow_result_impl { public: using type = typename recursive_arrow_result_impl< T >::type; }; template< typename T > using recursive_arrow_result_impl_t = typename recursive_arrow_result_impl::type; template< typename T > recursive_arrow_result_impl_t recursive_arrow_impl(T&& r , typename std::enable_if< has_arrow< T >::value >::type* = NULL ) { return recursive_arrow_impl(std::forward(r).operator->()); } template< typename T > T& recursive_arrow_impl(T& r , typename std::enable_if< !has_arrow< T >::value >::type* = NULL ) { return r; } template< typename T > recursive_arrow_result_impl_t recursive_arrow_impl(T* r) { return recursive_arrow_impl(*r); } template< typename T > using recursive_arrow_result_t = std::remove_reference_t< recursive_arrow_result_impl_t< T > >*; template< typename T > recursive_arrow_result_t recursive_arrow(T&& r) { return std::addressof(recursive_arrow_impl(std::forward(r))); } } template< typename T > detail::recursive_arrow_result_t recursive_arrow(T&& r) { return detail::recursive_arrow(std::forward(r)); } } template< typename T > std::invoke_result_t< decltype(&recursive_dereferencing::recursive_arrow), T&& > recursive_arrow_func(T&& r) { return recursive_dereferencing::recursive_arrow(std::forward(r)); } On Monday, 29 October 2018 09:00:15 UTC+2, teco...@gmail.com wrote: > > Hi, > > If we have a container of unitque_ptr/shared_ptr objects, to reference to > them we can usethe follow notations: > > *p->FuncMember();* //Same as *(*p).FuncMember();* > > but, some times I need to create a pointer to this pointer and I use to > write the follow notation: > > *(*p2p)->FuncMember();* > > I think it will be a good idea if c++ could have a notation to this > situations like: > > *p2p=>FuncMember() *//or > > *p2p+>FuncMember()* //or > > *p2p#>FuncMember()* //or > > *p2p:>FuncMember()* > > What do you think? > > I hope I helped in some way. > > > -- You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group. To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org. To post to this group, send email to std-proposals@isocpp.org. To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/467a0621-ed78-4a96-b8f2-3485e059d840%40isocpp.org. ------=_Part_1659_1014403419.1541990464657 Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable
Suppose you had a template function recursive_arrow_f= unc(p) that recursively applies operator-> on p, as p.operator->().op= erator->().operator->() until it returns a pointer to an object type = that has no operator->

Then you could use it as:
recursive_arr= ow_func(p)->FuncMember();

Even if p was a p= ointer to pointer to pointer.

you could use this function to create = one of several possible syntaxes, using a keyword, say "arrows":<= br>
arrows(p)->FuncMember();
arrows[p]->FuncMember(= );
arrows{p}->FuncMember();
arrows--(p)->FuncMemb= er();
arrows--[p]->FuncMember();
arrows(p).FuncMember();
arrows[p].FuncMember();
arrows{p}.FuncMember();
arrows--(p).FuncMember();
arrows--[p].FuncMember();

It could even do= stuff like this:

template< typename T >
cl= ass my_ptr
{
private:
T* m;

public:
my_ptr(T* r) : m(r) {}

<= div>public:
T* operator-&= gt;() const
{
<= span style=3D"white-space:pre"> return m;
}

T& operator*() const
{
retur= n *m;
}
};


void g_test_recursive_arrow()
=
{
using element_t = =3D std::pair< double, double >;
element_t = a =3D { 1.5, 2.5 };

my_ptr< element_t > m =3D &a;
assert(a.first =3D=3D arrows(m)->first);
<= div>
my_ptr< my_pt= r< element_t > > mm =3D &m;
assert(a.first =3D=3D arrows(mm)->first);

=
my_ptr< my_ptr< my= _ptr< element_t > > > mmm =3D &mm;
assert(a.first =3D=3D arrows(mmm)->first);


element_t* p =3D &a;
assert(a.first =3D=3D arrows(p)->first);

element_t** pp =3D &p;
assert(a.first =3D=3D arrows(pp)->= first);

el= ement_t*** ppp =3D &pp;
assert(a.first =3D=3D arrows(ppp)->first);

<= br>
my_ptr< element_t = >* pm =3D &m;
asse= rt(a.first =3D=3D arrows(pm)->first);

my_ptr< element_t* > mp =3D &p;
assert(a.first =3D=3D arrow= s(mp)->first);


my_ptr< my_ptr< element_t >* > mpm =3D &= amp;pm;
assert(a.first = =3D=3D arrows(mpm)->first);

my_ptr< element_t* >* pmp =3D &mp;
assert(a.first =3D=3D arrows(pmp)-= >first);

}


<= /div>

Here's a possible implementation.
I needed = a traits 'has_arrow<T>' but I couldn't find it in boost, = so I used=C2=A0boost::has_dereference.
So classes with operator-> mus= t has operator* to be usable.


namespace recursiv= e_dereferencing {
namespa= ce detail {


template <typename T>
class has_arrow
{
public: = static const bool value =3D boost::has_dereference<T>::value;
};

template< typename = T >
class recursive_a= rrow_result_impl;

= template< typename T, bool >
class recursive_arrow_result_impl2
{
= public: using type =3D typename recursive_arrow_result_impl< st= d::invoke_result_t< decltype(&(T::operator->)), T > >::type= ;
};

template< typename T >=
class recursive_arrow_r= esult_impl2< T, false >
<= /span>{
public: using ty= pe =3D T & ;
};

template< = typename T >
class re= cursive_arrow_result_impl
{
public: using type = =3D typename recursive_arrow_result_impl2<T, has_arrow<T>::value &= gt;::type;
};
=
template< typena= me T >
class recursiv= e_arrow_result_impl<T*>
<= /span>{
public: using ty= pe =3D typename recursive_arrow_result_impl< T >::type;
};

template< typename T >
class recursive_arrow_result_impl<T= &>
{
public: using type =3D typename recu= rsive_arrow_result_impl< T >::type;
};

template< typename T >
class recursive_arrow_result_impl<T*&>
{
public: using type =3D typename recursive_arrow_result_= impl< T >::type;
}= ;

templat= e< typename T >
us= ing recursive_arrow_result_impl_t =3D typename recursive_arrow_result_impl&= lt;T>::type;


template< typename T >
recursive_arrow_result_impl_t<T>
recursive_arrow_impl(T&&= r
, typename std::ena= ble_if< has_arrow< T >::value >::type* =3D NULL
)
{
return= recursive_arrow_impl(std::forward<T>(r).operator->());
= }

template< typename T >
T& recursive_arrow_impl(T& r=
, typename std::enable= _if< !has_arrow< T >::value >::type* =3D NULL
)
{
return r;=
}

<= div> template< typename T >
recursive_arrow_result_im= pl_t<T*>
recursiv= e_arrow_impl(T* r)
{
return recursive_arrow_imp= l(*r);
}

<= /div>

template&= lt; typename T >
usin= g recursive_arrow_result_t =3D std::remove_reference_t< recursive_arrow_= result_impl_t< T > >*;

template< typename T >
recursive_arrow_result_t<T> recursive_a= rrow(T&& r)
{
return std::addressof(rec= ursive_arrow_impl(std::forward<T>(r)));
}

}

<= /span>template< typename T >
detail::recursive_arrow_result_t<T> recursive_arrow(T&&= amp; r)
{
return detail::recursive_arrow(std::for= ward<T>(r));
}

}


template<= typename T >
std::invoke_result_t< decltype(&recursive= _dereferencing::recursive_arrow<T>), T&& >
recur= sive_arrow_func(T&& r)
{
return recursive_dereferencing::recursive_arrow(std::forw= ard<T>(r));
}



=
On Monday, 29 October 2018 09:00:15 UTC+2, teco...@gmail.com wrote:
Hi,=C2=A0

If we have a container of unitque_ptr/shared_ptr ob= jects, to reference to them we can usethe follow notations:

<= /div>
p->FuncMember();=C2=A0=C2=A0 //Same as (*p).FuncMemb= er();

but, some times I need to create a point= er to this pointer and I use to write the follow notation:

(*p2p)->FuncMember();

I think i= t will be a good idea if c++ could have a notation to this situations like:=

p2p=3D>FuncMember() //or

=
p2p+>FuncMember() //or

p2p= #>FuncMember() //or

p2p:>FuncMember()=

What do you think?

I hope I helped in some way.


--
You received this message because you are subscribed to the Google Groups &= quot;ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposa= ls+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.= com/a/isocpp.org/d/msgid/std-proposals/467a0621-ed78-4a96-b8f2-3485e059d840= %40isocpp.org.
------=_Part_1659_1014403419.1541990464657-- ------=_Part_1658_1845307955.1541990464656-- .