Intelligent Easy i.e.Sensor & Robot

as a further explanation to:

” Comparsion of DateTime classes in popular programming Languages (1)”

This part is a copy and paste of lang/lib spec.

Continue reading →

C    boost::Datetime  Java JDK8(javax.time)  Qt Python and Javascript

(1) Table comparison

(2) Further explanation from each language spec

Joda package for (Java) is not described here, whose API is analoguous to Qt and Python. As there is new API of LocalDateTime,  it is the equivalent to QDatetime, and python’s datetime.

Continue reading →

Previous C++ standard is C++03 (2003); previous C std is C99.They are not released together, but they did this time as  a combo of C11 and C++11.

__STDC_VERSION__ == 201112L

C11 (formerly C1X) is an informal name for ISO/IEC 9899:2011  (see wiki)

http://en.wikipedia.org/wiki/C11_%28C_standard_revision%29

Continue reading →

see “Count with me: how many smart pointer classes does Qt have?”

http://blog.qt.digia.com/blog/2009/08/25/count-with-me-how-many-smart-pointer-classes-does-qt-have/

C++11 <smart_pointer>

Introduction to smart pointers:   http://en.wikipedia.org/wiki/Smart_pointer

Continue reading →

Threading is always tricky, I dare not comment on this topics.

If some useful articles are found, this page will be updated!

just read the article: < Understand the Qt containers >

http://marcmutz.wordpress.com/effective-qt/containers/

key points

(1) difference:

a)Qt Containers:  implicitly shared (Copy-On-Write) !

b) size type: QT return signed int, while STL return size_t (unsigned int)

c) Iterator

(2)Qt has C++ STL style API, stick to these API style(3) Usage QVector  instead of QList as much as possible

Qt containers and their STL counterparts

The following table summarises the main sequential and associative Qt containers and their STL counterparts. For the most part, we will ignore the string classes, even though technically, they are also containers.

QFile is the class for  everyday File IO, while C++ STL using  stream

===========based class: std::stream =========
<iostream> (qDebug()  or #include <iostream> cin/cout )
<fstream>  (QFile)
<sstream> (QBuffer)
<boost/archive> ( QDataStream for serialization )

===========QIODevice===========
The QIODevice class is the base interface class of all I/O devices in Qt.

#include <QIODevice>

Inherits: QObject.

Inherited by: Q3Socket, Q3SocketDevice,
QAbstractSocket, QBuffer, QFile, QLocalSocket, QNetworkReply,
and QProcess  ( just like bash shell pipe input and output, Python).

Continue reading →

compiling from soruce is hard, but it can be easy if you just want to link to it

Continue reading →

/**
Extended java bit manipulaiton example   BitDemo.java

wikipedia
bit shifting for C/C++ is implicitly dependent on the left-handside operand!(arithmatic for signed int)
The >> operator in C and C++ is not necessarily an arithmetic shift. Usually it is only an arithmetic shift if used with a signed integer type on its left-hand side. If it is used on an unsigned integer type instead, it will be a logical shift.

java 5 got Bit Manipulation,  but there is no unsigned int,
*For example, in Java and JavaScript, the arithmetic right shift operator is >>;
whereas the logical right shift operator is >>>.
(Java only has one left shift operator (<<), because arithmetic left shift and logical left shift have the same effect.)

Tips for C++ bitwise manipulaiton:
Using only unsigned int and explicitly specified the byte size,
defined variable/constant with full width to int type:  uint32_t d=0x000000FF;  // not as  0xFF
logic or arithmetic left shifting has the identical effect,  notably, a positive int can be << into nagetive int( overflow)!
that is why signed int bitwise is not recommended!

third kind of shifting is called circular shifting
*/
class BitDemo {
public static void main(String[] args) {
int bitmask = 0x000F;
int val = 0×2222;
// prints “2″
System.out.println(val & bitmask);
System.out.println(“Shifting test …”);
int a=1;
System.out.println(String.format(“a=%d, a<<2 = %d”,a, a<<2));  // multiply by 4
System.out.println(String.format(“a=%x, a>>2 = %x”,a, a>>2));  // div by 4 underflow -> 0
int b=0×80000008;
System.out.println(String.format(“b=%d, b<<2 = %d”,b, b<<2));
// sign bit is been replaced by 0, it is positive now
System.out.println(String.format(“b=%d, b>>2 = %d”,b, b>>2));
// arithmetic shifting, it is still negative int
System.out.print(“what happen if there is one bit moved to sign bit? for <<3 on c=”);
int c=0x1FFFFFFF;
System.out.println(c<<3);  // positive number become negative, overflow!
int d=0xFFFFFFFF;
System.out.print(“Before the >>> bitwise op, d=”);
System.out.println(d);
System.out.println(d>>>3);
}
}