Quote:Original post by azherdev
I just want my C# code to compile to native code... is that so much to ask? Darn framework.
Quote:Original post by Lodeboost::shared_ptr?
[...]-with easier support for making vectors pointers to a mix of parent and child classes with virtual functions, like pointer containers that automatically destroy objects, note that pointer containers aren't in the standard at the moment[...]
Quote:[...]-with a programmer NEVER needing to use "new" and "delete", with all situations that could require the use of those having a replacement that auto-deletes (for example the vectors and pointer containers)[...]So you're saying we should get rid of dynamic memory management and instead require programmers to use built-in types that perform similar but more limited roles?
Quote:[...]-with a MUCH simpeler form to use iterators to elements of containers, I'm sorry but I dislike a variable type with a name like std::vector<int>::iterator, there has to be a better way to handle this, if needed make containers and iterators part of the language itself, for example the type int+ could be an iterator to containers of ints[...]Is 'int+' a random access iterator, a bidirectional iterator (if not, which direction?), an inserter iterator (front or back?), and how do I overload the type 'int+' so I can make it behave differently?
Quote:[...]-with fixed point types[...]This is more a processor design issue IMO, and I still wonder why new processor designs don't include instructions for such a thing. Sure, it can be emulated with software, but its much slower than with dedicated hardware (much like emulating 128-bit floating point on an integer-only machine). I love my AMD hardware, but I really wish they had introduced fixed-point instructions with their AMD64 architecture.
Quote:Original post by MaulingMonkeyThe alternative seems to be to make all function definitions inline with the class definition, which adds extra indenting and prevents decent organization. Well, that or you're just moving the header to the top of the source file and either losing static typing (with some kind of 'object' class that you have to cast around all the time as a kind of pseudodynamic typing) or preventing circular references between types.Quote:Original post by The C modest god
Actually I think headers are really good.
They violate the principle of DRY, or Don't Repeat Yourself. Better to have documentation autogenerated from the implementation source with the function signatures and synopsis than to be forced to manually write header files.
Quote:Original post by h3r3tic
Lenghty but interesting post ensues ...
Quote:Original post by daerid
Consider a class that as one of it's members has a HANDLE to an open file.
When the object dies, you don't necessarily care about how much memory it's taking up, but you definitely want that HANDLE to the open file to have CloseHandle() called on it, or you get an orphaned open file (one of the most annoying things about windows EVER).
Quote:Original post by Drakex
Alright then. This is a trivial example, but demonstrates a few key issues: operator overloading, templates, classes, and overall syntax:
import std.stdio;class MyContainer(T){ // snip T opIndex(uint index) in { assert(index >= 0 && index < mData.length); } body { return mData[index]; } T opIndexAssign(T value, uint index) in { assert(index >= 0 && index < mData.length); } body { return mData[index] = value; } // snip }// C++bool doSomething(){ // blah blah return false; // blah blah return true;}void someFunction(){ bool success = DoSomething(); if(!success) { // code to execute on failure } else { // code to execute on success } // code to execute always}void DoSomething(){ // blah blah throw new Exception("yadda yadda"); // blah blah}void SomeFunction(){ scope(exit) { // code to always execute when the function exits normally or otherwise } scope(failure) { // code to execute only during exception stack unwinding } scope(success) { // code to execute only when the function exits normally } DoSomething();}template <size_t X, size_t Y>class Matrix{//c'tors, d'tor & matrix maths operators};char[] foo = "foo bar";char[] bar = foo[4 .. $];// bar == "bar"int[char[]] myMap;myMap["foo"] = 1;myMap["bar"] = 2;myMap["baz"] = 3;writefln(myMap["bar"]);// prints '2'class Foo { this (int a) { this.a = a; } void foo() { writefln(a); } int a;}void main() { auto dg = &(new Foo(5)).foo; dg(); // prints '5'}auto x = 2 + 3.4f;writefln(typeid(typeof(x)));// prints 'float'template fact(int a) { static if (0 == a) { const int fact = 1; } else { const int fact = a * fact!(a - 1); }}void main() { writefln(fact!(4)); // prints '24'}void main() { void foo() { writefln("Yo !"); } foo();}void foo(int delegate() x) { writefln(x());}void main() { int someInt = 123; foo( { return someInt; } );}void main() { void foo(int[] arr ...) { writefln(arr); } foo(1, 2); // prints '[1,2]' foo(3); // prints '[3]'}int[] arr = new int[3];arr[10] = 4; // runtime exception with line numberswitch ("foo") { case "bar": writefln(1); break; case "foo": writefln(2); break; // that's the case :P}class Foo { int a = 5; int b = 3; typedef int Bar = 10; Bar c; // initialized to 10}Quote:Original post by DrakexQuote:Does anyone have some code that shows D doing something better than C++ or at least being done in a less complicated fashion?
Alright then. This is a trivial example, but demonstrates a few key issues: operator overloading, templates, classes, and overall syntax:
*** Source Snippet Removed ***
The equivalent in D:
*** Source Snippet Removed ***
Just........ yeah. THAT'S why I don't like C++ anymore.
Quote:Original post by Drakex
// Hell let's make an iterator, I don't have a clue how to do that in C++.
Quote:Original post by Nitage
How would you add a member function that sets the matrix to the identity matrix? In C++, you'd have to duplicate the entire class definition, using partial specialization to pick out square matrices (the only kind of matrices that have identity matrices).
#include <cstddef>#include <boost/utility/enable_if.hpp>#include <boost/mpl/equal_to.hpp>#include <boost/mpl/size_t.hpp>namespace mpl = boost::mpl;template < std::size_t M, std::size_t N >matrix<M, N>& identity(matrix<M, N>& m, typename boost::enable_if< mpl::equal_to< mpl::size_t<M>, mpl::size_t<N> > >::type* = 0) { /*<-insert-code->*/}//.... just imagine headers herenamespace mpl = boost::mpl;using namespace boost::mpl::placeholders;template < typename Matrix >struct sqr_matrix { Matrix& identity() { Matrix& this_ = static_cast<Matrix&>(*this); //....... return this_; } // add all other ops that are only for square matrix};template < std::size_t M, std::size_t N >struct matrix : mpl::if_< mpl::equal_to< mpl::size_t<M>, mpl::size_t<N> >, sqr_matrix< matrix<M, N> >, mpl::empty_base >::type{ .... };
