220 40975 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:53:12 -0800 (PST) Lines: 469 Approved: news@gmane.org Message-ID: References: <467a0621-ed78-4a96-b8f2-3485e059d840@isocpp.org> Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: blaine.gmane.org Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="----=_Part_1724_1356553565.1541991192228" X-Trace: blaine.gmane.org 1541991072 28237 195.159.176.226 (12 Nov 2018 02:51:12 GMT) X-Complaints-To: usenet@blaine.gmane.org NNTP-Posting-Date: Mon, 12 Nov 2018 02:51:12 +0000 (UTC) Cc: tecoberg@gmail.com To: ISO C++ Standard - Future Proposals Original-X-From: std-proposals+bncBCFJBV63SUOBBGOWUPPQKGQE4KRASQY@isocpp.org Mon Nov 12 03:51:07 2018 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-yw1-f69.google.com ([209.85.161.69]) by blaine.gmane.org with esmtp (Exim 4.84_2) (envelope-from ) id 1gM2Jb-00073y-FS for gclcip-std-proposals@m.gmane.org; Mon, 12 Nov 2018 03:51:03 +0100 Original-Received: by mail-yw1-f69.google.com with SMTP id w185-v6sf1582612ywa.2 for ; Sun, 11 Nov 2018 18:53:14 -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=NTZr4/OhB8EH9KknmNmlHEkW1E8cA70S2UWvAJj8MgY=; b=zBMSjemzu3mBEjvK3IUT3wGGpCd1QUmEiPuXoVpzVFMuTOXMoCEIoTX7gykcf+vao7 Flh3t7pdEm4RMb/lunT+0XM7ThiCUK4831wfgG52H5SwerNjjmMFmpWEmSJDDLfFqA3m LGLSYAX5b+7GupUvyJa7IzSZU7vSEix8fXFcf0S6kk4WQt3U9MIE93J4CTSPsndimsBJ Mru6Ne1Am9SAyBoS2VXWn4ijnGgB329eDbC1juOa4lIIGfIkwk+Nrn29jk/g39sJQXrO NJxC8ge/44E7I43WKH9UKm7PsSwzIdp/9prEet4xAWm7fTIkJfJtHeNeKhw4Jyybev66 b5xA== 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=NTZr4/OhB8EH9KknmNmlHEkW1E8cA70S2UWvAJj8MgY=; b=O8N9CRpKArCoh31E3ECQPcittIIwLI6A6JxuYkJXVJtEgRpu5a1bHq1rCcGMcFeYsA nhWd4W4sZK0/o62248f9shKrivws+DiCNWs+huWpXAzDeyFkglJit7pIR0EF/s8a4Fsy lmlW3ckTtLqnld7Hj6txgKOWHO1MdjU8JCTCkLIW9VU36l9LuJePL+zPVM+QChdjJvJE LNcK83cw662cynfBzcVuDFnbJ8PUs3I+5deHLLe7ZY9MG4b6SWeqQqp23X/4B2eau4wx 6EukLxZPPqPnLmBnddMOT4U8Mt3VesulYzAL0T55ja/k3KveYPULGxDsP7/iN03jalNt Zguw== 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=NTZr4/OhB8EH9KknmNmlHEkW1E8cA70S2UWvAJj8MgY=; b=EIAdjbSPPLoyeVCAxB4OtoOp6zRSPI0JytpeX6v1KZm7YI46iBdXUIiBQGkGosLBE0 ITFuMByIB24rubB14qh9T1e9T7pZ5s9cGUNyQborI5SWCSwPukA8eZdeEmFW4Mt8qWkU XfNt2JcDP3iT89uLS7GSSj8VRJm0VTuna4MDs7Df0VXqt4g+rXS6R3iv5V1hhoJ6XzLk ERqgIWs/J9CJD4C9InsCjH96LWG3gnKkuoONARand0DZ7QHm1/B6uPgX13tla8JmzwK/ k3wRgY8l9ZT2Yd0adnzoH4sTZScW5qp5ssveuUT7aTRCliS3pT5HkFFV3Y4jxnGmC6gW 9sig== X-Gm-Message-State: AGRZ1gIb7AVOog7GzTYxozowjb1N0sIy2MACnzTQoYJTKig8HXP09Rm0 Oj5YCKThHaxawV5wajzJ+Qjexw== X-Google-Smtp-Source: AJdET5dUicW3ySg9SUVTOkttsavAt8AirhB0VtvDjrPcbFn3lWS4qDClRORb2QoJ1zzLzewcIDva8A== X-Received: by 2002:a25:7805:: with SMTP id t5-v6mr3876082ybc.41.1541991193782; Sun, 11 Nov 2018 18:53:13 -0800 (PST) X-BeenThere: std-proposals@isocpp.org Original-Received: by 2002:a5b:446:: with SMTP id s6-v6ls3056606ybp.3.gmail; Sun, 11 Nov 2018 18:53:12 -0800 (PST) X-Received: by 2002:a25:d60d:: with SMTP id n13-v6mr179036ybg.7.1541991192715; Sun, 11 Nov 2018 18:53:12 -0800 (PST) In-Reply-To: <467a0621-ed78-4a96-b8f2-3485e059d840@isocpp.org> 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:40975 Archived-At: ------=_Part_1724_1356553565.1541991192228 Content-Type: multipart/alternative; boundary="----=_Part_1725_850149995.1541991192229" ------=_Part_1725_850149995.1541991192229 Content-Type: text/plain; charset="UTF-8" ....But I wholeheartedly recommend you don't do stuff like that. Dereferencing is an important construction in the logic of your code. The different between none, one or two dereferencing might be very meaningful to a reader of the code - these differences should be readily explicit. It might only make sense in extremely specialized situations, and I'd recommend that it you ever use such function make sure it only compiles for classes of a specialized concept. On Monday, 12 November 2018 04:41:04 UTC+2, Itaj Sherman wrote: > > 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 has_arrow::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/f8cda263-6bfd-477e-b4eb-ad73f6c7e915%40isocpp.org. ------=_Part_1725_850149995.1541991192229 Content-Type: text/html; charset="UTF-8" Content-Transfer-Encoding: quoted-printable
...But I wholeheartedly recommend you don't do stuff l= ike that.
Dereferencing is an important construction in the logic of you= r code. The different between none, one or two dereferencing might be very = meaningful to a reader of the code - these differences should be readily ex= plicit.
It might only make sense in extremely specialized situations, an= d I'd recommend that it you ever use such function make sure it only co= mpiles for classes of a specialized concept.

On Monday, 12 November = 2018 04:41:04 UTC+2, Itaj Sherman wrote:
Suppose you had a template function recurs= ive_arrow_func(p) that recursively applies operator-> on p, as p.operato= r->().operator->().operator->() until it returns a pointer to= an object type that has no operator->

Then you could use it as:<= br>recursive_arrow_func(p)->FuncMember();

<= div>Even if p was a pointer to pointer to pointer.

you could use thi= s function to create one of several possible syntaxes, using a keyword, say= "arrows":

arrows(p)->FuncMember();
arro= ws[p]->FuncMember();
arrows{p}->FuncMember();
arr= ows--(p)->FuncMember();
arrows--[p]->FuncMember(= );
arrows(p).FuncMember();
arrows[p].Fu= ncMember();
arrows{p}.FuncMember();
arrows--(p).FuncMem= ber();
arrows--[p].FuncMember();

=
It could even do stuff like this:

template< typename T ><= br>
class my_ptr
{
private:
T* m;

public= :
my_ptr(T* r) : m(r) {}<= /div>

public:
= T* operator->() const
= {
return m;
}

T& operator*() const
{
return *m;
}
};


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

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

my_ptr< my_ptr< element_t > > mm =3D &m;
assert(a.first =3D=3D arrows(mm)->fir= st);

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


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

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


my= _ptr< element_t >* pm =3D &m;
assert(a.first =3D=3D arrows(pm)->first);

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


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

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

}
<= br>


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


namespace recursive_dereferencing {
namespace detail {


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


template< typename T >
= class recursive_arrow_result_impl;

template< typename T, bool >
class recursive_arrow_result_im= pl2
{
public: using type =3D typename recursive_= arrow_result_impl< std::invoke_result_t< decltype(&(T::operator-&= gt;)), T > >::type;
};

temp= late< typename T >
class recursive_arrow_result_impl2< T, false >
{
= public: using type =3D T & ;
};

template< typename T >
class recursive_arrow_result_impl
{
public: using type =3D typename recursive_arrow_result_impl2<T,= has_arrow<T>::value >::type;
};

= template< typename T >
class recursive_arrow_result_impl<T*>
{
public: using type =3D typename recursive_arrow_result_imp= l< T >::type;
};

template&l= t; typename T >
class= recursive_arrow_result_impl<T&>
{
public: using type =3D typename recursive_arrow_result_impl< T >::t= ype;
};

template< typename T &= gt;
class recursive_arro= w_result_impl<T*&>
{
public: usin= g type =3D typename recursive_arrow_result_impl< T >::type;
};

template< typename T >
= using recursive_arrow_result_impl_= t =3D typename recursive_arrow_result_impl<T>::type;
<= br>

templ= ate< typename T >
= recursive_arrow_result_impl_t<T>
recursive_arrow_impl(T&& r
, typename std::enable_if< has_arrow&l= t; 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_arro= w< T >::value >::type* =3D NULL
)
{
return r;
}

template< typename T >
recursive_arrow_result_impl_t<T*= >
recursive_arrow_im= pl(T* r)
{
return recursive_arrow_impl(*r);
}

=
template< typena= me T >
using recursiv= e_arrow_result_t =3D std::remove_reference_t< recursive_arrow_result_imp= l_t< T > >*;

template< typename T >
recursive_arrow_result_t<T> recursive_arrow(T&&= amp; r)
{
return std::addressof(recursive_= arrow_impl(std::forward<T>(r)));
}

}

template< typename T >
= detail::recursive_arrow_result_t<T> recursive_arrow(T&am= p;& r)
{
return detail::recursive_arrow(std::= forward<T>(r));
}

}


temp= late< typename T >
std::invoke_result_t< decltype(&r= ecursive_dereferencing::recursive_arrow<T>), T&& &g= t;
recursive_arrow_func(T&& r)
{
return recursive_dereferencing::re= cursive_arrow(std::forward<T>(r));
}




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

If we have a containe= r of unitque_ptr/shared_ptr objects, to reference to them we can usethe fol= low notations:

p->FuncMember();=C2=A0=C2= =A0 //Same as (*p).FuncMember();

but, some = times I need to create a pointer to this pointer and I use to write the fol= low notation:

(*p2p)->FuncMember();

I think it will be a good idea if c++ could have a not= ation to this situations like:

p2p=3D>FuncMe= mber() //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/f8cda263-6bfd-477e-b4eb-ad73f6c7e915= %40isocpp.org.
------=_Part_1725_850149995.1541991192229-- ------=_Part_1724_1356553565.1541991192228-- .