const * std::vector<const int* const> const v = new std:vector<const int* const>();
v.push_back(dynamic_cast<const int* const>(new int(5)));
test.cpp: In function 'void print(const StringToStringMap&)':
test.cpp:8: error: conversion from
'std::_Rb_tree_const_iterator<std::pair<const std::basic_string<char,
std::char_traits<char>, std::allocator<char> >, std::basic_string<char,
std::char_traits<char>, std::allocator<char> > > >' to non-scalar type
'std::_Rb_tree_iterator<std::pair<const std::basic_string<char,
std::char_traits<char>, std::allocator<char> >, std::basic_string<char,
std::char_traits<char>, std::allocator<char> > > >' requested++iterator in a for loop is faster than iterator++.
@interface and @implementation and @end are sort of ugly though.
[AbsurdlyLongNames absurdlyLongNamesForClasses:functions:globals:]
0000111111111111000000000111111111111111111000000000001111111111000000000011111100000000000001111110
0000111111011111110000000111111111111111111000000111111100000011111110000011111100000000000001111110
0000111111000111111100000111111000000000000000011111100000000000011111100011111100000000000001111110
0000111111000000111110000111111000000000000000111100000000000000000011110011111100000000000001111110
0000111111000000011111000111111000000000000000111100000000000000000000000011111100000000000001111110
0000111111000000001111000111111000000000000000011111000000000000000000000011111100000000000001111110
0000111111000000000111100111111000000000000000000111111100000000000000000011111100000000000001111110
0000111111000000000011100111111111111110000000000000001111111111111100000011111100000000000001111110
0000111111000000000111100111111000000000000000000000000000000000001111000011111100000000000001111110
0000111111000000001111000111111000000000000000000000000000000000000011110011111100000000000001111110
0000111111000000011111000111111000000000000000000000000000000000000000110011111100000000000001111110
0000111111000000111110000111111000000000000000110000000000000000000001110011111100000000000001111110
0000111111000111111100000111111000000000000000011110000000000000011111100001111110000000000011111100
0000111111011111110000000111111111111111110000000011111000000000111100000000011111111111111111110000
0000111111111111000000000111111111111111110000000000001111111111110000000000000111111111111111000000
++valuevalue++Iter operator++ (int); might do something completely different than Iter& operator++ ();,for(vector<int> iterator it = v.begin(); it != v.end(); it++)for(vector<int> iterator it = v.begin(); it != v.end(); ++it)for is such a low-level construction.foreach construct wouldn't hurt. But it certainly won't solve all of C++'s problems, and knowing it, will introduce some more.
class Outer {
int m_var;
class Inner {
int get() {
return m_var;
}
}
Inner get_inner() {
return new Inner();
}
}
Outer o = new Outer();
o.m_var = 1;
Inner i1 = o.get_inner();
o.m_var = 2;
Inner i2 = o.get_inner();
class Outer
{
private int var;
class Inner
{
int get() { return var; }
}
Inner getInner() { return new Inner(); }
void setVar(int v) { var = v; }
public static void main(String[] args)
{
Outer o = new Outer();
o.setVar(1);
Inner i1 = o.getInner();
o.setVar(2);
Inner i2 = o.getInner();
if(i1.get() == 1 && i2.get() == 2)
System.out.println("Worked!");
else
System.out.println("Failed!");
}
}(define var 1)
(define (inner)
(lambda () var))
(define i1 (inner))
(set! var 2)
(define i2 (inner))> (i1)> (i2)(define (plus x)
(lambda (y) (+ x y)))
(define plus3 (plus 3))
(define plus2 (plus 2))final int[] env = {31337};
Runnable closure = new Runnable() {
@Override
public void run() {
System.out.println("env was " + env[0]);
env[0] = 31338;
System.out.println("env is now " + env[0]);
}
};
closure.run();