220 14357 <2f256fe9-0799-46c8-ab46-f8789f013cfd@isocpp.org> article Path: news.gmane.org!not-for-mail From: Mantosh Kumar Newsgroups: gmane.comp.lang.c++.isocpp.proposals Subject: Safe version of malloc wrapper using C++11 to avoid signed/unsigned conversion Date: Sat, 1 Nov 2014 05:58:20 -0700 (PDT) Lines: 412 Approved: news@gmane.org Message-ID: <2f256fe9-0799-46c8-ab46-f8789f013cfd@isocpp.org> Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/alternative; boundary="----=_Part_500_1841120845.1414846700852" X-Trace: ger.gmane.org 1414846712 19212 80.91.229.3 (1 Nov 2014 12:58:32 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Sat, 1 Nov 2014 12:58:32 +0000 (UTC) To: std-proposals@isocpp.org Original-X-From: std-proposals+bncBDVMFP64YYBRB3VR2ORAKGQEALIE6IQ@isocpp.org Sat Nov 01 13:58:24 2014 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-ob0-f198.google.com ([209.85.214.198]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1XkYG7-0003Zc-PD for gclcip-std-proposals@m.gmane.org; Sat, 01 Nov 2014 13:58:24 +0100 Original-Received: by mail-ob0-f198.google.com with SMTP id m8sf36754076obr.1 for ; Sat, 01 Nov 2014 05:58:22 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=date:from:to:message-id:subject:mime-version:x-original-sender :reply-to:precedence:mailing-list:list-id:list-post:list-help :list-archive:list-subscribe:list-unsubscribe:content-type; bh=LFv5cMRpQMsr5ZV2ZEaiEcQTNqOUx54UjnYtOzoG+Fo=; b=hXNhUUpEhiLFACSxPOKhiH5BGb4VFxtBHYyyYgd9DLzRx87ow9/CT61rS2t5OnYBde Y9A8cQaPa3npmenS4cUO0MMac2kCrLpMT0HHDIK8i/cjSNGHrQ5fKrlE762i5csfzY0b Odi9p45rEYwcoNIB1NAz00FnLalOVpDKsO8WYBEDbytjLqnUG416exvArKSgUK7meJUy FvXIJgl6H/+6HuEmqZU08Y85Aw3DSat/FA8o3nSp1+o3EbNsX57DZBrTxALxNTciGXt3 yAnOZJ0UmtkB8asbUf4PNBghyqOaH2vV9KzSeWIhKoQGHhgL7yjDIXA5OqJN8kIr883B GeyA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:date:from:to:message-id:subject:mime-version :x-original-sender:reply-to:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-subscribe:list-unsubscribe :content-type; bh=LFv5cMRpQMsr5ZV2ZEaiEcQTNqOUx54UjnYtOzoG+Fo=; b=Ogw32R9G/jylszrULG8bbDnPUUtDP/us1NySiRGn2cOcVj2tU2jE+nHTN/pTfE08Hs 4Kox9LTlpN4YtILWOesWxwi5q/HJreygD1nimi4B01kBvd47dRN8FLCddvpNlK6eCmk6 Z8emRP48pbpFF0Sc4rVTTymlX3xLk6lksNaWW13irmeb3KlkmZmm0pIOJ7Fueo2tsB9D 7WfjemRCSi5F4aJm1qYSutuF0bsOq4e7VoQGVylpvs0kDePr1gl9baJ3ogb0r4fXsRwQ hbQktbn5U0YWyI8cbF9gPGxlqL1Z1Ss7n9je4i4pImiHpMtyZ/BG3gXoZ9h00wXF5var BuHg== X-Gm-Message-State: ALoCoQmTz7lrmITftLaLVJenrn5HXh6UR0AaYY/M+vjuYYDqqcmYcum5IWAgAEpwkNmTt8IDVdRf X-Received: by 10.43.130.74 with SMTP id hl10mr22862769icc.26.1414846702837; Sat, 01 Nov 2014 05:58:22 -0700 (PDT) X-BeenThere: std-proposals@isocpp.org Original-Received: by 10.50.23.8 with SMTP id i8ls470407igf.34.canary; Sat, 01 Nov 2014 05:58:22 -0700 (PDT) X-Received: by 10.50.3.4 with SMTP id 4mr32352igy.15.1414846702446; Sat, 01 Nov 2014 05:58:22 -0700 (PDT) X-Original-Sender: mantosh4u@gmail.com Precedence: list Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org List-ID: 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:14357 Archived-At: ------=_Part_500_1841120845.1414846700852 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: quoted-printable *malloc()* is still very important function in C program while writing low= =20 level library .However we know that this function can create all sorts of= =20 problem if you are not aware of some of its internal concepts. The argument= =20 type of *malloc()* is of *size_t* type which is typedef of some unsigned.= =20 Now if our program passes the argument to malloc() by *signed int* variable= =20 and if it becomes some negative value due to some reason, we are in big big= =20 trouble. Because under this situation, system would interpreted as requests= =20 for huge amounts of space, which will often fail. This would lead to=20 program crash at the point depending on how you have handled/used this=20 returned memory in code.=20 While learning C++11 template metaprogramming and type_traits concepts, I= =20 wrote small wrapper function of malloc which would avoid such scenario=20 while compiling and report the compilation error.=20 The above program was written for learning purpose and to demonstrate the= =20 usage of type traits functionality. In C++ way, we should not use naked=20 pointer and use of malloc() as it creates all sort of problem related to=20 memory management. malloc() is taken as example just to show how *we can=20 write better type safer(signed/unsigned conversion) and not to promote the= =20 usage of malloc()*. I would also like to know yours opinion about - Does the above malloc wrapper function make sense?=20 - Shall we use it in our program instead of malloc()?=20 - What could be the disadvantage of above function? #include#include templateconstexpr bool Is_unsigned_number() { return std::is_un= signed::value; } templatevoid check_unsigned() { static_assert(Is_unsigned_number(), "Non Unsigned Type Data Passed");= } templatevoid* my_malloc(T val) { check_unsigned(); return malloc(val);} Case1 =3D=3D=3D=3D=3D int main() { unsigned int sz1 =3D 10; void* a =3D my_malloc(2*sz1); *(int *)a =3D 0;} Output: Pass Case2 =3D=3D=3D=3D=3D int main() { void* a =3D my_malloc(-1); *(int *)a =3D 0;} Output: Compilation Error basic.cpp: In instantiation of =E2=80=98void check_unsigned() [with T =3D i= nt]=E2=80=99:=20 basic.cpp:14:21: required from =E2=80=98void* my_malloc(T) [with T =3D int]= =E2=80=99=20 basic.cpp:19:28: required from here basic.cpp:9:3: error: static assertion= =20 failed: Non Unsigned Type Data Passed static_assert(Is_unsigned_number()= , "Non=20 Unsigned Type Data Passed"); ^ Case 3 =3D=3D=3D=3D=3D=3D int main() { signed int sz =3D 10; void* a =3D my_malloc(sz); *(int *)a =3D 0;} Output: Compilation Error basic.cpp: In instantiation of =E2=80=98void check_unsigned() [with T =3D i= nt]=E2=80=99:=20 basic.cpp:14:21: required from =E2=80=98void* my_malloc(T) [with T =3D int]= =E2=80=99=20 basic.cpp:20:28: required from here basic.cpp:9:3: error: static assertion= =20 failed: Non Unsigned Type Data Passed static_assert(Is_unsigned_number()= , "Non=20 Unsigned Type Data Passed"); ^ Obviously Case 3 should have been allowed(as its value is positive) but its= =20 limitation of this approach(type traits) it checks for the type and not the= =20 value as these checks happens in the compile time. There would be also 2-3= =20 different function of my_malloc() instantiated by compiler instead of just= =20 one. my_malloc(unsigned int)=20 my_malloc(unsigned long)> --=20 ---=20 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 e= mail to std-proposals+unsubscribe@isocpp.org. To post to this group, send email to std-proposals@isocpp.org. Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa= ls/. ------=_Part_500_1841120845.1414846700852 Content-Type: text/html; charset=UTF-8 Content-Transfer-Encoding: quoted-printable


malloc() i= s still very important function in C=20 program while writing low level library .However we know that this function= can create all sorts of=20 problem if you are not aware of some of its internal concepts. The=20 argument type of malloc() is of size_t ty= pe which is typedef of some unsigned. Now if our program passes the argumen= t to malloc() by signed int variable and if it becomes some negative value due to some reason, we=20 are in big big trouble. Because under this situation, system would=20 interpreted as requests for huge amounts of space, which will often=20 fail. This would lead to program crash at the point depending on how you have handled/used this returned memory in code.

While learning C++11 template metaprogramming and type_traits=20 concepts, I wrote small wrapper function of malloc which would avoid=20 such scenario while compiling and report the compilation error.

The above program was written for learning purpose and to demonstrate=20 the usage of type traits functionality. In C++ way, we should not use=20 naked pointer and use of malloc() as it creates all sort of problem=20 related to memory management. malloc() is taken as example just to show=20 how we can write better type safer(signed/unsigned conversion) and not= =20 to promote the usage of malloc().


I would also like to kn= ow yours opinion about

  • Does the above malloc wrapper function make sense?
  • Shall w= e use it in our program instead of malloc()?
  • What could be the dis= advantage of above function?


#include<type_traits>=
;
#include<cstdlib&g=
t;

template<typename T>
constexpr bool =
Is_unsigned_number() =
{ return std::=
is_unsigned<T>::value; }

template<typename T>
void check_unsigned()  {
  static_assert(Is_unsigned_number<T>(), "Non Unsigned Type  Data Passed");
}

template<typename T>
void* my_malloc(T val) {
 check_unsigned<T<=
/span>>();
 return malloc=
(val);
}




Case1
=3D=3D=3D=3D=3D
int main<=
span class=3D"pun">() {
     unsigned =
int  sz1 =3D 10;
     void* a =3D my_malloc(2<=
span class=3D"pun">*sz1);
     *(int *)a =
=3D 0;
}


<=
span class=3D"pun">Output: Pass




Case2
=3D=3D=3D=3D=3D

=
int=
 main() {
     void* a =3D my_malloc(-1=
);
     *(int *)a =
=3D 0;
}


=
Output: Compilation Error

basic.cpp: <= /span>In instantiation of =E2=80=98void check_unsigned() [with T =3D int]=E2=80= =99:
basic.cpp<= span class=3D"pun">:14:21: required from =E2=80=98void<= /span>* my_malloc(T) [with T =3D int]=E2=80=99
basic.cpp<= span class=3D"pun">:19:28: required from here basic.cpp:9:3: error: <= span class=3D"kwd">static assertion failed: Non Unsigned= Type Data Passed static_assert(Is_unsigned_number<T>(), "Non Unsigned Type Data Passed"); ^


<=
span class=3D"pun">



Case 3
=3D=3D=3D=3D=3D=3D

=
int=
 main() {
     signed int sz =3D 10;
     void* a =3D my_malloc(sz=
);
     *(int *)a =
=3D 0;
}



Output: Compilation Error

basic.cpp: <= /span>In instantiation of =E2=80=98void check_unsigned() [with T =3D int]=E2=80= =99:
basic.cpp<= span class=3D"pun">:14:21: required from =E2=80=98void<= /span>* my_malloc(T) [with T =3D int]=E2=80=99
basic.cpp<= span class=3D"pun">:20:28: required from here basic.cpp:9:3: error: <= span class=3D"kwd">static assertion failed: Non Unsigned= Type Data Passed static_assert(Is_unsigned_number<T>(), "Non Unsigned Type Data Passed"); ^



=

Obviously Case 3 should have been allowed(as its= value is positive)=20 but its limitation of this approach(type traits) it checks for the type=20 and not the value as these checks happens in the compile time. There=20 would be also 2-3 different function of my_malloc() instantiated by=20 compiler instead of just one.

my_malloc<unsigned int>(unsigne= d int)
my_malloc<unsi= gned long>(unsigned long)>

=

--

---
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.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposals/<= /a>.
------=_Part_500_1841120845.1414846700852-- .