Missing some C++ features in Java

General Discussions
#1

Im working in a C++ project now and i wish i could have some C++ features in Java.

It’s nice to have sinonims of types using typedef . This is almost essential when working with templates.

Simplified constructor syntax: Vector x(1,2,3); instead of Vector x = new Vector(1,2,3);

Structured primitive data. Its a pain not having this is Java. Syntax would be simply:

@primitive class Vector { float x; float y }

Defines a final class whose methods are all final if exist.

No arrays bound checks: @nocheck int[] x

Sure there would be problems but the Java VM could have an option to run some classes in unsafe mode by setting a security policy for these classes.

Operator overloading: Vector x,y; x * y instead of x.multiply(y). It’s dumb to use the word multiply or even worst mul if we can and should use the * operator.

#2

That’s the cool thing about Java! You don’t have a bloated list of features, that you don’t really need.

How about adding automated garbage collection to C++? Another nice thing is the amazing number of libraries (all free and really easy to use) in Java! Cool are the automatic array bounds checks, so you are not stuck with error messages such as “Segmentation Fault” like in C++.

Not allowed as well are assembly istructions in Java such as (whatever that is):

      asm ("int \$0x80\n"
               : "=a" (sys)
               : "0" (sys), "b" (parm) );
#3

such features might be nice for the programmer, but are a pain in the arse for everybody else, who want’s to read and understand the code or even worse: trace bugs.

#4

that and easier is quite relative, we use ide’s these days not notepath, vi, vim or what not.

and if certain tooling would become better I’d hardly type at all.

operater overloading might look nice in the beginning but it backfires like a cannon.

#5

I have yet to understand how adding “sinonyms” to classes would help. If I have a “HashMap<Node, Node>” would it be better to know right away that it’s a HashMap than find something like “Arc”? What’s “Arc”? Is it a class, I don’t find it in any package!? Where is it defined? Oh wait, a very intelligent developer called a HashMap an Arc.

I think this is a bug not a feature. Once I confronted a Python developer about this, Python has something similar, he told me that the “IDE would facilitate things”. That’s funny.

When it comes to bash Java then IDEs don’t count, comparing isolated features is ok. When things get ugly for them then the IDE matters! :slight_smile:

#6

err?

no wenn it comes to (over)shorting syntax, that and introducing multply ways of defining the samething, everything should be kept as simple as possible but not simpler.

not sure what you gettign at if a subclass is called something well thats the developers fault if it isn’t clear upon choosing the name, document you classes etc. I’m probebly missing the point?

#7

I didn’t understand your text, sorry.

I was criticizing typedef and I think it’s bad. The classes should have meaningful enough names and not need sinonyms.

#8

oh, nm I see you where refering to somethign else the reference to ide’s kinda confused me.

#9

The problem with using templates is that meaningful names usualy become very long and you can’t allways avoid it:

Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>

Now try to create a new object with this:

Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>> x =
new Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>>(arguments);

It’s even worst when you have a factory method:

HashmapFactory<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>> xfactory =
HashmapFactory<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>>.getFactory();
Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>> x = xfactory.getInstance();

It would be a lot easier to write:

Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>> x();

For what i know theres no IDE that rewrites the syntax of a language so you still have a readbility problem.

#10

wheres the problem here? the lengthy constructor or the lengthy classname/discription?

Hashmap<Integer,Set<Pair<? extends Something,? extends Something>>> is just long.
a shortcut constructor isn’t really saving you from that.

I thought there was an artikel on onjava or something going about something like this:


HashMap<Integer,Set<Pair<? extends Something,? extends Something>>> dataStructure = newDataStructure(2);

public <A,B> HashMap<Integer, Set<Pair<A,B>>> newDataStructure(int capacity) {
    return new HashMap<Integer,Set<Pair<A,B>>>(capacity);
}

came across it yesterday by accident, can’t find it anymore.

I haven’t yet found it annoying enough to spend time to figure out a more elegant way of tackleing the problem.

#11

I think there are really some c++ features that would be nice to have in java. I am not sure about the typedef, since you are rarely in the need of such complicated generics usages. My wishlist would mainly contain two things:

  • operator overloadng (using math libraries without it is really a pain)
  • real templates (the java generics stuff is really just useful for collections)

Thereare several other things like properties and structs I would also like to have, but the two above are the things I really miss the most.

#12

typedefs are more useful in C++ when you have to declare a long list of methods of class that return a very long and hard to read type.

It’s much easier to read (lets call it alias instead of typedef):

After working with more than one oo programming language that provide type aliases i miss them in Java in situations like this. It’s not a big deal but it makes coding easier just like operator overloading when well used of course.

I never understood very well why we can’t have primitive values in templates. It would go realy well with primitive classes the whay i described them above. Sometimes i wish i could build my own Java language compiler without all these limitations.

#13

[quote]Sometimes i wish i could build my own Java language compiler without all these limitations.
[/quote]
http://pizzacompiler.sourceforge.net/ :wink:

#14

[quote]It would be a lot easier to write:

Hashmap<Integer,Set<Pair<SomethingA extends Something,SomethingB extends Something>>> x();
[/quote]
You invalidate all of your arguments when you make this statement.

#15

Maybe I’m being “too creative” here but I think we can do more with Generics than Collections, for example:

I have an interface:


public interface Handler<T extends Something> {
    void handle(T something);
}

Then create a class like:


public CarHandler implements Handler<Car> {
    public void handle(Car car) {
      // do something.
    }
}

If I used an interface instead of Generics I wouldn’t be able to access the fields and other methods not specified in the interface without a Cast, and then bad things could happen.

#16

Genetrics are there for compile time type safety. there are not coupled with collections it’s just that with collections it’s evident why you would want type safety.

use Genetrics where you need type safety.

#17

That’s exactly the reason, why I criticized generics in my comments. They are nothing more than a type safety construct, which is a good thing, but mainly only useful for collections, since most other use cases are covered by inheritance in conjunction with interfaces. I was used to treat templates like… eh, well… templates :). In c++ templates are more of a compiler macro definition. The restrictions of the java generics implementation does not allow for more advanced usages like for example mixins (Yes, there are some tricky ways to simulate mixin behaviour, but they are messy).

#18

Personally, I loathe Templates with a passion. Code bloat, incomprehensible error messages, slow compilation… no thanks! Not to mention that the STL (as useful as it is!) was designed by a twisted and deranged mind. The fact that there are lots of C++ programmers who think that the STL is an example of good design is a sad commentary on C++ programmers :o).

Anyway, the bottom line is that if you prefer C++, use it! Clearly, everyone here finds Java a better fit for their needs JUST AS IT IS :o) If we all thought Templates were the be all and end all, we’d be using C++, right?

#19

[quote=“kaffiene,post:18,topic:26600”]
What does that have to do with what i wrote?

[quote=“kaffiene,post:18,topic:26600”]
Don’t see the connection at all. Templates were copied from other languages and they existed long before C was ever invented.

Edit for correction: C was copied from other languages too.

#20

the discovery qoute popped up in my head reading the reply.

“if change is good why test it?”
“if change is wrong where would we be today?”
etc.

anyways to get right on topic,
language changes: “language X has foo, we need foo in language Y too!” now at this point I’m not for change or against it, the only thing I ask is why? and what? Why should it change, and what happence if we don’t change it. How is a result of the 2 former conclusions. Now this sounds simple but as with most things that appear simple, it’s not as straightforward as you would like it to be.

in this case for example “We need templates” the aswer at this point is no we absolutly do not need them, templates are a means to an end, and we don’t know to what end we want to go where. (ClassCastException : problem expected but solution found, for the geeks.) In other words what do we want? “Templates!” uge ugem, In other what do we want to achieve? and why is solution x the way to go? Some might yell that here problem x is selfevident and that it’s self evident what the solution would be. Perhaps but it’s better to avoid guessing and to reflect. 90% of all conflicts are because of communication errors or rather the lack of communication.

Communication is like (unit) tests it might go fine without them or …yeah…