• Post Reply Bookmark Topic Watch Topic
  • New Topic
programming forums Java Mobile Certification Databases Caching Books Engineering Micro Controllers OS Languages Paradigms IDEs Build Tools Frameworks Application Servers Open Source This Site Careers Other Pie Elite all forums
this forum made possible by our volunteer staff, including ...
Marshals:
  • Campbell Ritchie
  • Jeanne Boyarsky
  • Ron McLeod
  • Paul Clapham
  • Liutauras Vilda
Sheriffs:
  • paul wheaton
  • Rob Spoor
  • Devaka Cooray
Saloon Keepers:
  • Stephan van Hulst
  • Tim Holloway
  • Carey Brown
  • Frits Walraven
  • Tim Moores
Bartenders:
  • Mikalai Zaikin

Is this the right forum ?

 
Greenhorn
Posts: 18
  • Mark post as helpful
  • send pies
    Number of slices to send:
    Optional 'thank-you' note:
  • Quote
  • Report post to moderator
Hi all,
Awhile back, I posted the questions below regarding implicit narrowing conversions but unfortunately haven't received any replies. Would asking these questions be more appropriate in the intermediate forum ? The questions were more why's than how to's but I seem to recall seeing similar discussions on other topics.
Thanks !


My Java text mentions the following as conditions that must hold for implicit narrowing conversions on assignment

  • the source is a constant expression of either byte,short,char or int
  • the destination is either byte,short or char
  • the value of the source is determined to be in the range of the destination at compile time


  • Then it goes on to say that no implicit narrowing conversions whatsoever are allowed on passing to method parameters.
    My first question is - why only allow types narrower than long ? Why not allow (for example) a constant double value that is in range ?
    My second question is - why not allow any narrowing at all for parameter passing ? My understanding is that parameters are really created only when methods are called at runtime, but if the rules above hold wouldn't it make sense to be consistent with the treatment of assignments as is the case in other operations ?

     
    Sheriff
    Posts: 7023
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    My first question is - why only allow types narrower than long ? Why not allow (for example) a constant double value that is in range ?
    In a nutshell, because that's what the original language and compiler designers decided. Perhaps because someone lost a bet, flipped a coin, or it was actually a little bit easier or faster to implement the compiler in such a manner.
    I don't think that it would be terribly difficult to add a little extra functionality to a compiler to allow it to consider double and long values for possible automatic narrowing upon assignment. But it would be just another little neat thing that could mildly complicate the compiler implementation, as well as mildly slow it down.
     
    Dirk Schreckmann
    Sheriff
    Posts: 7023
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    My second question is - why not allow any narrowing at all for parameter passing ? My understanding is that parameters are really created only when methods are called at runtime, but if the rules above hold wouldn't it make sense to be consistent with the treatment of assignments as is the case in other operations ?
    I'd imagine that a few folks feel it's not appropriate for a compiler to do any automatic narrowing. If you want a float, make it a float by casting it.
    I'd guess that it's entirely possible and conceivable to create a compiler that would allow automatic narrowing of larger data type values known at compile time, which are passed as arguments to a method. But, again, this would likely complicate the compiler implementation mildly, as well as slow it down a bit.
    So, again, these aspects of the Java programming language and compiler are this way because that's just how the original language and compiler designers wanted it - probably because it was easier and faster to implement.
     
    Ranch Hand
    Posts: 121
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    Hi,
    This is right forum....
    thanks
    Anurag
     
    Ranch Hand
    Posts: 382
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator

    Originally posted by Dirk Schreckmann:
    My second question is - why not allow any narrowing at all for parameter passing ? My understanding is that parameters are really created only when methods are called at runtime, but if the rules above hold wouldn't it make sense to be consistent with the treatment of assignments as is the case in other operations ?
    I'd imagine that a few folks feel it's not appropriate for a compiler to do any automatic narrowing. If you want a float, make it a float by casting it.
    I'd guess that it's entirely possible and conceivable to create a compiler that would allow automatic narrowing of larger data type values known at compile time, which are passed as arguments to a method. But, again, this would likely complicate the compiler implementation mildly, as well as slow it down a bit.
    So, again, these aspects of the Java programming language and compiler are this way because that's just how the original language and compiler designers wanted it - probably because it was easier and faster to implement.


    Narrowing a larger to a smaller data type can cause data to be truncated; possible even lose precision. You don't want a compiler to make such decisions if the losing of precision or data truncation can cause serious problems. It makes more sense to force the programmer to think about the data type and let the programmer decides if the data type should be narrowed.
     
    David Fishman
    Greenhorn
    Posts: 18
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    Thanks to all who replied !
     
    David Fishman
    Greenhorn
    Posts: 18
    • Mark post as helpful
    • send pies
      Number of slices to send:
      Optional 'thank-you' note:
    • Quote
    • Report post to moderator
    This is a reply to a thread from a few months back, however I thought I would share something I found recently in the JLS regarding not allowing implicit narrowing conversions for parameter passing. Basically the prior replies were on the right track, and here is what section 5.3 of the JLS indicates :


    ...Method invocation conversions specifically do not include the implicit narrowing of integer constants which is part of assignment conversion. The designers of the Java programming language felt that including these implicit narrowing conversions would add additional complexity to the overloaded method matching resolution process...


    More details can be found in the JLS.
    I will also post the same reply in a related thread I started Jan 1, 2004 titled �implicit narrowing conversions� just for completeness.
     
    Consider Paul's rocket mass heater.
    reply
      Bookmark Topic Watch Topic
    • New Topic