Developers Factory

Multi-character literal (Multiple characters inside single quotes) Vs char literal in C, C++

2017-03-09T08:33:00.001+05:30

Any character with in single quotes('a') is a character literal (character constant) and a string literal is a set of characters with in double quotes ("Hello").
And if we have multiple characters in side single quote('aa') ,it is a multi-character literal

Before going to the multi-character literal we will check how these literals are considered (as value and type) by compiler. In C language type of character literal is int. So size of char literal is 4 bytes in 32 bit architecture. Where as in C++ the type of character literal is char and size is 1 byte.

Save following program with .c and .cpp extension and run with c and cpp compiler.

 int main()  
 {  
 printf("Size of char literal %d\n",sizeof('a'));  
 return 0;  
 }

What is the value of multiple characters inside single quotes?

But for multi-character literal, type is int in C, C++ and the value is implementation defined.

The value of an integer character constant containing more than one character or containing a character or escape sequence that does not map to a single-byte execution character (C90 6.1.3.4, C99 and C11 6.4.4.4). It is implementation defined. Reference LINK

The value of multi character literal as implementation for gnu compiler is as follows.

The compiler evaluates a multi-character character constant a character at a time, shifting the previous value left by the number of bits per target character, and then or-ing in the bit-pattern of the new character truncated to the width of a target character. The final bit-pattern is given type int, and is therefore signed, regardless of whether single characters are signed or not. If there are more characters in the constant than would fit in the target int the compiler issues a warning, and the excess leading characters are ignored.
For example, 'ab' for a target with an 8-bit char would be interpreted as ‘(int) ((unsigned char) 'a' * 256 + (unsigned char) 'b')’, and '\234a' as ‘(int) ((unsigned char) '\234' * 256 + (unsigned char) 'a')’.
Reference LINK

Example calculation:

The So for the multi character literal 'aa', the value is calculated as in GNU

(int) 'a' * 256 + (int) 'a' (Here 256 = 16^2)
(97*256) + 97 = 24929

'aaa' is valued as

(int)'a' * 65536 + (int) 'a' * 256 + (int) 'a' (Here 65536 = 16^4)
(97*65536) + (97*256) + 97 = 6381921

Example Program:

 #include<iostream>  
 using namespace std;  
 int main()  
 {  
 cout<<'aaa'<<endl;  
 return 0;  
 }

Output:
6381921

When to use dynamic_cast and static_cast in C++

2017-03-08T20:19:00.000+05:30

Dynamic Cast:

Dynamic cast is used to convert a pointer (or reference) to base type to pointer (or reference) to derived type, iff the base pointer/reference refers to derived type. This is called down casting. (Base -> Derived)
This type of casting is used when these two types are polymorphic (means base class should have virtual methods).
No need of explicit type casting when we want to convert a pointer (or reference) to derived type to pointer (or reference) to base type. This is called up casting. (Derived-> Base )
If you use dynamic_cast for non-polymorphic classed it will through compile time error
This cast is mainly used to execute the derived type specific functionality when we have base class pointer/reference. (Throgh base pointer/reference we cannot access derived type specific fucntionality)
dynamic_cast safely convers to derived type in run-time, if it fails to convert it will return NULL when target is pointer type, throws bad_cast exception when target type to convert is reference.

Example:

 #include<iostream>  
 #include<typeinfo>  
 using namespace std;  
   
 class Base  
 {  
 public:  
   virtual void display() {  
     cout<<"Base: Display "<<endl;  
   }  
 };  
   
 class Derived: public Base  
 {  
 public:  
   void display() {  
     cout<<"Derived: Display "<<endl;  
   }  
   void myderfun() {  
     cout<<"Derived: myderfun "<<endl;  
   
   }  
 };  
   
 int main()  
 {  
   Base baseobj;  
   Derived derivedobj;  
   
   Base *pbaseobj = new Base();  
   pbaseobj->display();  
   
   Base *pbaseRefDerived = new Derived();  
   pbaseRefDerived->display();  
   
   Derived *pderivedobj1 = dynamic_cast<Derived*>(pbaseRefDerived); // valid  
   pderivedobj1->display();  
   
   Derived *pderivedobj2 = dynamic_cast<Derived*>(&baseobj); // invalid, returns null pointer  
   if(pderivedobj2)  
     pderivedobj2->display();  
   
   Derived &rderivedobj1= dynamic_cast<Derived&>(*pbaseRefDerived); // valid  
   rderivedobj1.display();  
   
   try {  
   Derived &rderivedobj2= dynamic_cast<Derived&>(baseobj); // invalid, throws bad_cast exception  
   rderivedobj2.display();  
   }  
   catch(bad_cast e) {  
     cout<<"exception caught:: "<<e.what()<<endl;  
   }  
   return 0;
 }

Output:

Static Cast:

Static cast is used to convert pointers of related class types (should have inheritance relation for class types)
It can not convert between unrelated class types
It is used to force the implicit conversion ex: short to int, int to float conversion
It can also used to convert void* to specific pointer type iff void* was obtained from that specific pointer type.
There is no overhead of runtime type checking in static_cast as in dynamic_cast

Example:

 #include<iostream>  
 using namespace std;  
 class Base  
 {  
 public:  
   void display() {  
     cout<<"Base: Display b:"<<b<<endl;  
   }  
   int b;  
 };  
   
 class Derived: public Base  
 {  
 public:  
   void display() {  
     cout<<"Derived: Display b:"<<b<<" d:"<<d<<endl;  
   }  
   void myderfun() {  
     cout<<"Derived: myderfun "<<endl;  
   }  
   int d;  
 };  
   
  int main()   
  {   
   Base *pbaseobj = new Base();  
   pbaseobj->b = 1;  
   pbaseobj->display();  
   
   Derived *pDerived = new Derived();  
   pDerived->b = 2;  
   pDerived->d = 3;  
   
   Base *pbaseRefDerived = pDerived;  
   pbaseRefDerived->display();  // display() not a virtual function 
   
   Derived *pderivedobj1 = static_cast<Derived*>(pbaseobj);  
   pderivedobj1->display();  
   
   Derived *pderivedobj2 = static_cast<Derived*>(pbaseRefDerived);  
   pderivedobj2->display();  
   
  return 0;  
   
  }

Output:

C++11 Features (Part 1)

2017-01-08T15:35:00.001+05:30

Here i'm listing some of the C++ 11 features we can use frequently.

1.Auto

2.Range Based for loop

3.Strongly typed enums
4.Forward enum declaration

To use C++ 11 features when compiling in commad line use any of the following flags

  $g++ -o myprog myprog.cpp -std=c++0x  (or)  
  $g++ -o myprog myprog.cpp -std=gnu++0x (or)  
  $g++ -o myprog myprog.cpp -std=c++11

Auto:

Before C++11 auto keyword is used in the storage class, from C++11 it is used as type inference, means automatic deduction of data type of an expression.

We can use auto inside the blocks, namespaces, and for loop initialization etc. Using auto we can reduce writing the some complex type declarations like iterators intialization in loop.

We cannot use auto in return type in fuction definition, but we can use auto for the return type when calling function.

Example:

 #include<iostream>  
 #include<map>  
 using namespace std;  
 int add(int a,int b)  
 {  
 return a+b;  
 }  
 auto g=7;  
 int main()  
 {  
 int arr[5] = {0,1,2,3,4};  
 std::map<int,std::string> mapNumbers;  
 mapNumbers[1] = "One";  
 mapNumbers[2] = "two";  
 mapNumbers[3] = "three";  
 mapNumbers[4] = "four";  
 auto temp = add(1,2);  
 cout<<g<<endl;  
 for(auto i : arr) //range based for loop  
 {  
 cout<<i<<" ";  
 }  
 cout<<endl;  
 for(auto itm: mapNumbers) //range based for loop  
 {  
 cout<<itm.first<<" "<<itm.second<<"\n";  
 }  
 return 0;  
 }

$ g++ -o autoexample autoexample.cpp -std=c++0x

$./ autoexample

0 1 2 3 4

1 One

2 two

3 three

4 four

Range Based for loop:

Range based for loops allows us 'foreach' like accessing of elements of an array, list, initializer list or containers. When we are doing operations on the elements of the array/containers but we don't need index of the array/containers we are accessing, then this range based for loops are useful.

Example:

 #include<iostream>  
 #include<vector>  
 using namespace std;  
 int main()  
 {  
 std::vector<int> vec = {1,2,3,4,5};  
 float farr[] = {6,7,8,9,10};  
 for(int i: vec)  
 {  
 cout<<i<<" ";  
 }  
 cout<<endl;  
 for(float f: farr)  
 {  
 cout<<f<<" ";  
 }  
 cout<<endl;  
 for(int t: {1,3,5,7,9})  
 {  
 cout<<t<<" ";  
 }  
 cout<<endl;  
 return 0;  
 }

Strongly typed enum:

To overcome the limitations and drawbacks of the old style enums C++11 introduces strongly types enums.

In Old style

enums are implicitly converted into integers
enum constants are exposed to surrounding name scope, so name clashes happens

enum colors { RED,GREEN, ORANGE};

enum fruits { ORANGE, APPLE, BANANA}; // name clash for ORANGE

We cannot specify the underlying enum type (size of enum)

So to overcome these drawbacks, c++11 introduces strongly typed enums.

Ex: enum class colors { RED,GREEN, ORANGE };

enum class xyz : unsigned long {x1, x2, x3};

enum class abc : char {a1, a2, a3};

We can access this enum with scope (colors::RED) or like old style (RED)

Forward enum declaration:

We can have forward declaration of enums like below, and after that we will define enum xyz

 enum class xyz ;  
 void fun(xyz var);

Example:

 #include<iostream>  
 using namespace std;  
 class Sample  
 {  
 public:  
 enum class color; //forward declarion  
 void fun(color c)  
 {  
 cout<<"fun "<<(int)c; // no implicit conversion, explicitly convert  
 }  
 enum class color: int  
 {  
 RED=1, GREEN, ORANGE  
 };  
 enum class fruits : char  
 {  
 APPLE=1, MANGO, ORANGE // same name ORANGE, this leads to error in old style  
 };  
 };  
 int main()  
 {  
 Sample s;  
 s.fun(Sample::color::ORANGE);  
 }

How to use Valgrind for debugging C/C++ program

2016-12-19T09:27:00.001+05:30

Valgrind tool is used to for memory leaks, uninitialized memory, reading or writing to memory that has been freed, invalid access to memory(boundary conditions for the dynamic arrays), mismatched use of malloc/new/new[] with free/delete/delete[] , double free/delete.

How to use Valgrind:

>Compile the program with -g option (this option will add debugging symbols), so that we can see line numbers of the program when debugging

 $ g++ -o test -g test.cpp

>use valgrind command to analyze

 $ valgrind --tool=memcheck --leak-check=yes ./test

Example: test.cpp
The following example demonstrates the debugging C++ program for

memory leak when the memory allocated with new don’t find delete

mismatched new/new[] with delete/delete[] operators. When we create heap memory for arrays of objects/variables we use [], and when delete also we have to use []

Boundary conditions for the allocated memory(index out of range).

uninitialised variable when used in the conditions.

 #include<iostream>  
 using namespace std;  
 int main()   
 {  
  int i;  
  char *c = new char;  //no delete for this memory allocated  
  char *s = new char[10];   
  s[10] = 'w'; //Invalid access  
  if(i) { //Uninitialised variable i  
  cout<<"Hello ";  
  }  
  delete s; //mis matched delete  
  return 0;  
 }

when you compile above program and run valgrind tool the following result will come

$ g++ -o test -g test.cpp

$valgrind --tool=memcheck --leak-check=yes ./test

 ==5455== Memcheck, a memory error detector  
 ==5455== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.  
 ==5455== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info  
 ==5455== Command: ./test  
 ==5455==   
 ==5455== Invalid write of size 1  
 ==5455==  at 0x8048634: main (test.cpp:11)  
 ==5455== Address 0x432906a is 0 bytes after a block of size 10 alloc'd  
 ==5455==  at 0x402B454: operator new[](unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)  
 ==5455==  by 0x8048628: main (test.cpp:10)  
 ==5455==   
 ==5455== Conditional jump or move depends on uninitialised value(s)  
 ==5455==  at 0x804863C: main (test.cpp:13)  
 ==5455==   
 ==5455== Mismatched free() / delete / delete []  
 ==5455==  at 0x402ACFC: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)  
 ==5455==  by 0x804865D: main (test.cpp:17)  
 ==5455== Address 0x4329060 is 0 bytes inside a block of size 10 alloc'd  
 ==5455==  at 0x402B454: operator new[](unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)  
 ==5455==  by 0x8048628: main (test.cpp:10)  
 ==5455==   
 Hello ==5455==   
 ==5455== HEAP SUMMARY:  
 ==5455==   in use at exit: 1 bytes in 1 blocks  
 ==5455==  total heap usage: 2 allocs, 1 frees, 11 bytes allocated  
 ==5455==   
 ==5455== 1 bytes in 1 blocks are definitely lost in loss record 1 of 1  
 ==5455==  at 0x402B9B4: operator new(unsigned int) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)  
 ==5455==  by 0x8048618: main (test.cpp:8)  
 ==5455==   
 ==5455== LEAK SUMMARY:  
 ==5455==  definitely lost: 1 bytes in 1 blocks  
 ==5455==  indirectly lost: 0 bytes in 0 blocks  
 ==5455==   possibly lost: 0 bytes in 0 blocks  
 ==5455==  still reachable: 0 bytes in 0 blocks  
 ==5455==     suppressed: 0 bytes in 0 blocks  
 ==5455==   
 ==5455== For counts of detected and suppressed errors, rerun with: -v  
 ==5455== Use --track-origins=yes to see where uninitialised values come from  
 ==5455== ERROR SUMMARY: 4 errors from 4 contexts (suppressed: 0 from 0)

>Corrected Version of the above program: The following program is the modified version of the above program with all the above problems corrected.

 #include<iostream>  
 using namespace std;  
 int main()   
 {  
  int i=1;  
  char *c = new char;    
  char *s = new char[10];   
  s[9] = 'w';   
  if(i) {   
  cout<<"Hello ";  
  }  
  delete c;  
  delete s[];   
  return 0;  
 }

PS: valgrind will not check for the invalid access(boundary conditions) of arrays allocated in stack.

Dynamic memory allocator: new in C++

2016-09-06T22:15:00.000+05:30

In c++ we will use new operator to allocate memory dynamically . In this post we will know how this process happens and what are the steps involved while using new. Basic syntax for new is

new [placemenet-params] typename;

This expression will allocate the memory available from the free store and returns the pointer to the object of type 'typename'. And in case of class, struct types it will allocate memory and intialise the object then retun the pointer to the object 'typename'.

Here 'placemenet-params' is optional and it will be usefull when we overload the new operator. This will be usefull particularly when hardware dependent objects to be allocated at a specified address.

Example:
int *p = new int;

char *arr = new char[10]; //for array of 10 chars

ExampleClass *obj = new ExampleClass();

> Call to new internally invokes 'operator new' function available globally to allocate memory for all types. If you overload operator new function for the particular class then the overloaded version will be called (operator new function of the class). This function will take size_t type as argument to allocate the number of bytes and returns the pointer to the object of typename.

And we can pass any number of arguments to this overloaded operator new function which are passed as placemenet-params.

Ex: ExampleClass *obj = new (0x00AA) ExampleClass();

here (0x00AA) will be the extra parameter for the operator new function.

> If you want to meke a call to the globally available operator new function , rather the class specific operator new function used scope resolution(::) before new

Example: Type-name t = ::new Type-name;

Object Slicing in C++ with example

2016-07-02T18:50:00.002+05:30

What is Object Slicing?
When an instance of derived class is copied to base class object by value , part of members associated with derived object will be lost(sliced) . Here base class object discards the data related to the derived class because base class object don't have information about the derived members

When we copy derived obj by value to base obj, the base class copy constructor /assignment operator will call (copy constructor will call at assigning object at the time of declaration (or) pass by value argument to function and assignment operator will call when assigning object after declarion), so base class don't have information about the derived members to copy. This means the base copy/assignment will copy members related to base class only.

The following sample c++ code will explain the above description.

#include<iostream>
using namespace std;
class Base
{
public :
    Base(){
        cout<<"Base default constructor\n "<<endl;
    }
    Base(const Base &obj)
    {
        cout<<"Base copy constructor\n "<<endl;
    }
    Base& operator=(const Base &ob)
    {
        cout<<"Base assignment op overload\n"<<endl;
        return *this;
    }
    virtual void display() {
        cout<<"Base disp "<<"\n\n";
    }
};

class Derived:public Base
{
public :
    Derived():Base()
    {
        cout<<"Derived default constructor\n"<<"\n";
    }
    Derived(const Derived &obj):Base(obj)
    {
        cout<<"Derived copy constructor\n "<<endl;
    }
    Derived& operator=(const Derived &ob)
    {
        cout<<"Derived assignment op overload\n"<<endl;
    }
    virtual void display() {
        cout<<"Derived disp "<<"\n\n";
    }
};

void copyByVal(Base obj)
{
    cout<<"Copy by Val fun: ";
    obj.display();
}
void copyByRef(Base &obj)
{
    cout<<"Copy by Ref fun: ";
    obj.display();
}

int main() {

    //Version1: to call copy constructor
    Derived d1;        //Base default constructor
                       // Derived default constructor

    Base b = d1;       //Base copy constructor
    b.display();       //Base disp
    Base &b1 = d1;
    b1.display();       //Derived disp

     //Version1: to call assignment operator
    Derived d2;        //Base default constructor
                              //Derived default constructor

    Base b2;          //Base default constructor
    copyByVal(d2); //Base copy constructor

                            //Copy by Val fun: Base disp
    copyByRef(d2); //Copy by Ref fun: Derived disp
    return 0;
}

OUTPUT:
Base default constructor

Derived default constructor

Base copy constructor

Base disp

Derived disp

Base default constructor

Derived default constructor

Base default constructor

Base copy constructor

Copy by Val fun: Base disp

Copy by Ref fun: Derived disp

>And the following program will explain you how object slicing occurs when we copy derived class object by value to base class object

#include<iostream>
using namespace std;
class Base
{
public :
    Base(int a){
        baseVal=a;
        cout<<"Base "<<baseVal<<"\n";
    }

    virtual void display() {
        cout<<"Base disp "<<baseVal<<"\n";
    }

protected:
    int baseVal;
};

class Derived:public Base
{
public :
    Derived(int a,int b):Base(a),derVal(b)
    {
        cout<<"Derived "<<a<<" "<<b<<"\n";
    }

    virtual void display() {
        cout<<"Derived disp base & der vals "<<baseVal<<" "<<derVal<<"\n";
    }
private:
    int derVal;

};

void copyByVal(Base obj)
{
    cout<<"Copy by Val fun: ";
    obj.display();
}

void copyByRef(Base &obj)
{
    cout<<"Copy by Ref fun: ";
    obj.display();
}

int main() {
    Base b(1);
    Derived d(4,5);

    copyByVal(d);

    copyByRef(d);

    Base b2(2);
    Derived d2(5,6);
    b2 = d2;
    b2.display();

    return 0;
}

OUTPUT:
Base 1
Base 4
Derived 4 5
Copy by Val fun: Base disp 4
Copy by Ref fun: Derived disp base & der vals 4 5
Base 2
Base 5
Derived 5 6
Base disp 5

In the above example
b2 = d2 and copyByVal(d); statements copied only part of the base members (sliced away derived members) to derived object from derived object.

Some Useful My Sql Queries for beginners

2016-06-08T20:54:00.000+05:30

My Sql is a popularly used Relational Database Management System. Database is used store and retrieve data efficiently with the proven algorithms. Here i'm providing some sql commands which are useful for beginners in my sql queries.

Here information_schema is the default database comes with Mysql installation.

>To check the engine used for the table - mytable

SELECT TABLE_NAME, ENGINE FROM information_schema.TABLES WHERE TABLE_NAME='mytable' AND TABLE_SCHEMA='mydatabase';

>To see the database create statement

SHOW CREATE DATABASE mydatabase;

>TO see the current database name

SELECT DATABASE();

>To see the table structure (create table statement)

SHOW CREATE TABLE mydatabase.mytable;

> Describes the all the columns and datatypes for the table

DESCRIBE mytable (or) DESC mytable;

>To see the warnings of the previous command

SHOW WARNINGS;

>To concatenate (Combine) and show the column vaues

SELECT CONCAT(firstname, ' . ', lastname) AS `Full Name`, marks FROM mytable;

>To Select rows in random order every time

SELECT * FROM mytable ORDER BY RAND();

> To retrieve multiple rows with the given values, for example to fetch 3 records data with column "uid" values as 5,6,8

SELECT * FROM mytable WHERE uid IN (5,6,8);

> To get summary report for the groups use GROUP BY aggregate functions(COUNT, MIN, MAX, AVG, SUM...) on the groups, for example to get the total number of students for each branch

SELECT COUNT(*) from mytable GROUP BY branchname;

To get the average marks in subject-wise

SELECT AVG(marks) from classtable GROUP BY subjectname;

To get the sum of the items in the stock

SELECT SUM(items) from stock GROUP BY itemname;

>To combine the results of two or more tables(identical) use UNION, for example to get the highest marks in the particular subject from class9table, class10table

SELECT MAX(science) FROM (SELECT MAX(science) from class9table UNION SELECT MAX(science) from class10table) as t1

Maria DB Storage Engines and Alogorithms used for Indexing

2016-05-26T21:27:00.001+05:30

Maria DB is a Open source database and is a replacement for My SQL data base after My Sql (Sun Micro Systems) has been acquired by Oracle.

Database can have multiple tables and each table will use one storage engine, and we can use different storage engines for different tables in the database.

In this article i'm discussing about the storage engines of Maria DB. There are many storage engines that supports Maria DB, and these are pluggable engines.

To see the available storage engines in maria db, execute the following query

MariaDB [(none)]> show storage engines; (or)

MariaDB [(none)]> show engines;

And for all these storage differ from one another with the following properties..

>Storage, indexes, data types, transactions(for data reliability), locking level(concurrent access), caching, memory usage ...

Here i'm providing the some of the Maria DB engines and their details..

1. Inno DB:
>This is the default storage engine for the Maria DB
>Transaction Safe : means automatic recovery, backup, rollback can be executed
>Memory caching
>Supports Row level locking
>Indexes are B-Tree data structures (R-Trees data structure for spatial indexes)
>adaptive Hash indexes (fastest way to perform querying)
>Crash recovery

2.MyISAM:
>Execellent INSERT performance.
>Non-transaction safe
>No foreign key support
>Usage : logging
>This default storage engine in Mysql from v3.23

3.MEMORY:
>Hash indexes
>Indexes are Red-black binary tree data structures
>Not support BLOB, TEXT data types
>Excellent INSERT and SELECT query performance
>Data stored in RAM rather than disk (the tables will empty after system restart)

4.ARCHIVE:
>Stores large amounts of data by compressing it
>Select and INSERT operations only
>No indexes

5.CSV:
>No indexes
>Not supports transactions
>Columns must be declared as Not NULL

6.FederatedX (FEDERATED):
>No data is maintained in local tables.
>Used to access data from the remote tables without using clustering technology
>Querying the local FederatedX table will fetch the data from the remote table

7.ARIA:
>Available in Maria DB only (not in Mysql)
>Good performance for quries with GROUP BY, DISTINCT as it has better caching mechanism compared to MyISAM

8.ARCHIEVE:
>No indexes
>Used to store large amounts of data (internally it will use gzip to compress rows)

9. CASSANDRA:
>Flexible scheme using Dynamic columns

10.CONNECT:
>Supports Text (CSV, INI, FMT, XML, FIX) , Binary (BIN, DBF, VEC) file format tables

11.OQGraph:
>Transactional and crash-safe
>Uses Dijkstra's algorithm and breadth-first search

12.Sequence:
>Virtual Read-only tables

13.TokuDB:
>Transactional
>fast recovery
>Fractal-Tree indexexes
>faster INSERT
>saving space by comression (space saving upto 90%)

Qt C++ to Qml Communication using qmlRegisterUncreatableType()

2016-05-12T23:55:00.003+05:30

In this article i will discuss about how to access the C++ class enum types and attributes in qml file using Qt c++ qmlRegisterUncreatableType() template function.

qmlRegisterUncreatableType() will register the c++ class type (derived from QObject) as the non-instantiable type with QML type system. So we can not create object for the class in qml file, but we can use the properties ans enumerated types belongs to this class in qml file.

To access the enum values in qml , we have to make it available to meta-object system with the following macro, Otherwise we cannot access in qml file.

Q_ENUMS(enumType)

To Register the c++ type with qml type system

qmlRegisterUncreatableType("ModuleName/uri", MajorVersion, MinorVersion, "QmlName", "message");

Here i'm providing the sample code to demonstrate the use of qmlRegisterUncreatableType() to access c++ class attributes and enum types.

Note: C++ class must be QObject derived to register with qml type system

>main.cpp

#include <QApplication>
#include <QQmlApplicationEngine>
#include <QtQml>

#include "mycppclass.h"
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    MyCPPClass myCppObj;
    qmlRegisterUncreatableType<MyCPPClass>("MyModule",1,0,"MyCPPClass","can not instantiate MyCPPClass in qml");

    QQmlApplicationEngine engine;
    engine.rootContext()->setContextProperty("myCppObj",&myCppObj);
    engine.load(QUrl(QStringLiteral("qrc:/main.qml")));

    return app.exec();
}

>MyCPPClass.h

#include <QObject>
#include <QString>
#include<QColor>

class MyCPPClass : public QObject
{
    Q_OBJECT
    Q_PROPERTY(QColor mycolour READ mycolour WRITE setMycolour NOTIFY mycolourChanged)
    Q_PROPERTY(int num READ num WRITE setNum NOTIFY numChanged)

    Q_ENUMS(NumbersType)

public:
    explicit MyCPPClass(QObject *parent = 0);

    QColor mycolour();
    void setMycolour(QColor clr);

    int num();
    void setNum(int n);

    Q_INVOKABLE QString getClassName();

    enum NumbersType {
        ONE = 1,
        TWO = 2,
        THREE = 3,
        FOUR= 4,
        FIVE = 5,
        SIX = 6,
        SEVEN =7 ,
        EIGHT = 8,
        Nine = 9
    };

signals:
    void mycolourChanged();
    void numChanged();

public slots:

private:
    QColor m_colour;
    int m_num;
};

Note:To access enum types in qml file we have to start enum values with Capital letter. Ex: Nine = 9

>MyCPPClass.cpp

#include "mycppclass.h"

MyCPPClass::MyCPPClass(QObject *parent) : QObject(parent)
{
}

QColor MyCPPClass::mycolour()
{
    return m_colour;
}

void MyCPPClass::setMycolour(QColor clr)
{
    m_colour = clr;
    Q_EMIT mycolourChanged();
}

int MyCPPClass::num()
{
    return m_num;
}

void MyCPPClass::setNum(int n)
{
    m_num = n;
    Q_EMIT numChanged();
}

QString MyCPPClass::getClassName()
{
    return "MyCPPClass";
}

and finally
>main.qml

import QtQuick 2.4
import MyModule 1.0

Rectangle {
        Component.onCompleted: {
            myCppObj.mycolour = "red"
            myCppObj.num = 300;
        }
        height: myCppObj.num
        width: myCppObj.num
        color: myCppObj.mycolour

        Text {
            id: name
            text: qsTr("This is from C++ class:\t"+myCppObj.getClassName()+" \n enum value: "+MyCPPClass.EIGHT)
        }
    }

Output:

Bit Operations: Qt Example

2016-05-07T19:57:00.000+05:30

In this post i'm going to show you some bit operations with &, |, <<, >>, ~ using Qt example. This example include operations like set a particular bit in the given number, clear bit, check bit is set or not and to check whether the number is even or odd.

Following demonstrates the psuedo code of the operations.

> To Set a bit in the given number : perform Betwise OR (|) operation with 1 left shift(<<) by index of the bit to set

num = num | (1<<index);

>To clear a bit in the given number: perform Betwise AND (&) operation with the inverted(~) 1 left shift(<<) by index of the bit to clear

num = num & ~(1<<index);

>To Check whether a bit is set or not: perform Betwise AND (&) operation between num right shift(>>) by index of the bit to check and 1

num = (num >> index) & 1;

>To Check whether a num is even or odd: perform Betwise AND (&) operation with 1. If it returns 1 number is odd, if returns 0 even number

bool ret = (num & 1);

And the following code demonstrates the sample Qt application example for the above operations.

#include <QCoreApplication>
#include<QDebug>

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    quint8 testByte = 8;

    qDebug()<<"test byte: "<<testByte;

    //set bit at 2nd index
    testByte = testByte | (1<<2);
    qDebug()<<"After set bit at 2nd index: "<<testByte;

    //clear bit at 3rd index
    testByte = testByte & ~(1<<3);
    qDebug()<<"After clear bit at 3rd index: "<<testByte;

    //check bit at 2nd index
    bool isBitChecked = (testByte>>2) & 1;
    qDebug()<<"check bit at 2nd index: "<<isBitChecked;

    //to find the number is even or odd
    qint32 num = 3;
    QString evenOdd = (num & 1)? "Odd":"Even";
    qDebug()<<"num 3 is : "<<evenOdd;

    return a.exec();
}

output:
test byte: 8
After set bit at 2nd index: 12
After clear bit at 3rd index: 4
check bit at 2nd index: true
num 3 is : "odd"

'Cannot find -lGL' error while building the Qt widget application in Linux OS?

2016-05-03T22:08:00.001+05:30

Hi all,

Did any one get "Cannot find -lGL" error while building the Qt widget application in Ubuntu operating system? Qt installer provides compiler, debugger, make and other tools for the development. But when you want to develop Qt graphical based application it requires Open GL libraries.

Most of the Linux OS will not provide Open GL libraries as default. To continue building Qt graphical applications just install this libraries.

For Ubuntu use the following command

$sudo apt-get install build-essential libgl1-mesa-dev

For Fedora/ RHEL

$sudo yum groupinstall "C Development Tools and Libraries"

$sudo yum install mesa-libGL-devel

Anonymous Unions in C++

2013-06-28T20:56:00.000+05:30

Unions in C++ are special type of classes. We can declare member functions and variables with in the union in c++ (all 'C' features of union remain same).

But in the unions all the data members share the same memory location.

Union members are public by default as like structures.

Anonymous unions are the special type unions with the no name and so we can not create object for that union. All the member data in the anonymous unions share same memory location. We can directly access the these members without any dot operator with in the block where these unions declared.

The scope of the anonymous union members restricted to the block where it declared and these members can be treated as the local varibles to that block, so there shouldn't be any conflict between the names of the variables defined with in the unions and variables defined with in the block.

For example:

 #include<iostream>  
 #include<cstring>  
 using namespace std;  
 int main()  
 {  
   union   
   {  
     int i;  
     char ch[4];  
   };  
   i = 56;  
   cout<<"i val: "<<i<<" ch val:"<<ch<<endl;  
   memcpy(ch,"1",sizeof(ch));  
   cout<<"i val: "<<i<<" ch val:"<<ch<<endl;  
   return 0;  
 }

Output:

i val: 56 ch val:8

i val: 49 ch val:1

Here union member data i and ch are having same scope as the variables declared with in the main block. Here i and ch share the same memory location so when we set ivalue ch value is also same. Ascii values 48 to 57 represents 0 to 9 decimal numbers.

Note: Alls the restrictions applicable to the unions in c++ are also applicable to anonymous unions

-->

Qt QML Introduction and Simple Example Program

2013-05-27T08:56:00.000+05:30

QML is declarative language used to develop user interface, is a part of the Qt Quick module. Qt Quick consists of set of technologies including Qml, C++ API's for integrating Qml with Qt application, Qt creator IDE, rum time support.

Qt Quick module comes with the Qt with 4.7 or later versions.

Qml we use elements to draw something on the screen(output) like text, image, rectangle etc.Every element in the qml is like a object. We cal also implement javascript code in side the qml file. Item is the base type for the all the elements.

To start a Qml Application we need to import Qt Quick module with version in the beginning of the every qml file, because the elements we are going to use included in this module. For example the following element displat a rectangle.

Import QtQuick 1.0

Rectangle {

    id: rect

    width: 300

    height: 300

    color: "red"

Every element will have properties (with values) to describe it, in the above example id, width, height and color are some properties of the rectangle. The “id” property is used to refer the particular element inside another element. We can put any number of elements inside another element will become child elements.

Proprty binding is the important feature of the qml, means we can use the expression or other properties as the values for the property , so that it will be updated when ever the corresponding proprty updated

Ex: Rectangle {

width: 300

height: width * 2

}

Here height will be updated when ever the width changes

The basic types for the property values are int, real, strings, boolean values, constants, color etc

Comments start with // same as c++ comments.

Writing a First Qt Qml Program:

To start first Qml app follow below

Open Qt Creator
Click on Create Project in File menu (File > New File or Project)
Select Qt Quick Project then Qt Quick Application, then click choose as shown in the following image
Give the project name and location then click next
Select Built-in elements only (for all platforms) [depending on our requirement]
Then select the target type
Then Click on finish

Note: these steps may slightly change depend on the platform and Qt version

The default main.qml will open with some code (try executing that code), remove the code and write your own code

The following simple Qml program wil change between two colors on clicking on the rectangle

Code: main.qml

// import QtQuick 1.0 // to target S60 5th Edition or Maemo 5

import QtQuick 1.1

Rectangle {

    id: mainRect

    property bool toggle: false

    width: 360

    height: 360

    MouseArea {

        anchors.fill: parent

        onClicked: {

            console.log("parent")

            toggle = !toggle

            if(toggle)

                mainRect.color = "red"

            else

                mainRect.color = "blue"

-->

Output:

What is the sizeof array type when passed as a function argument?

2013-01-25T17:56:00.000+05:30

Sizeof() operator is used to find out the no. of memory bytes occupied by any datatype i.e. it will calculate the size of the given datatype. So if we pass a variable called i of type int, it will give output as 4 bytes, or if we pass a array type say arr which contains declaration as int arr[10] , it will give 40 as output.

We generally use sizeof() operator on array type to find out the number of elements an array contain by dividing the sizeof array by oth element of array (or any element).. The following program will illustrate this

#include<stdio.h>
int main()
{
    int arr[10],s;
    s=sizeof(arr)/sizeof(arr[0]);
    printf("sizeof arr %d\n",sizeof(arr));
    printf("no. of elements of arr %d\n",s);
    return 0;
}

Here the problem is what is the size of the array type in function when we pass it as a argument. This is something different because when we pass array as an argument, the array type decays to pointer. So we can't calculate the no.of elements in the function. This is described by the following program.

#include<stdio.h>
void fun(int arr[])
{
    int s,i;
    s= sizeof(arr)/sizeof(arr[0]);
    printf("fun: sizeof arr %d\n",sizeof(arr));
    printf("fun: no.of elements %d\n",s);
    for(i=0;i<s;i++)
        printf("arr[%d] %d\n ",i,arr[i]);
}
int main()
{
    int arr[10]={1,2,3,4,5,6,7,8,9,10},s;
    s= sizeof(arr)/sizeof(arr[0]);
    printf("main: sizeof arr %d\n",sizeof(arr));
    printf("main: no.of elements %d\n",s);
    fun(arr);
    return 0;
}

Output:

main: sizeof arr 40

main: no.of elements 10

fun: sizeof arr 4

fun: no.of elements 1

arr[0] 1

-->

As the array type decays into pointer, so its size will be size of int (4 bytes). So 4/4 which gives 1 as the no.of elements.

To get the no.of elements of array, we need to pass it as an another argument to the function as below.

             void fun(int arr[],int size);

If you like this article

Which algorithm is efficient for swapping?

2012-12-31T20:56:00.000+05:30

Swapping of two numbers/characters can be done by different ways. Generally all people know swapping using a temporary variable.
In this post i will tell you how to swap two variables in 3 different ways, and which algorithm is efficient to swap the variables.

Here all the below examples are shown in C code(executed in linux environment with gcc compiler).

Method 1:

Swapping using a temporary variable:

#include<stdio.h>

void swap(int*,int*);

int main()

    int a,b;

    printf("enter 2 numbers\n");

    scanf("%d %d",&a,&b);

    printf("before swapping: a=%d b=%d\n",a,b);

    swap(&a,&b);

    printf("After swapping: a=%d b=%d\n",a,b);

    return 0;

void swap(int *a ,int *b)

    int temp;

    temp=*a;

    *a=*b;

    *b=temp;

Method 2:


Swapping without using a 3rd variable


void swap(int *a,int *b)
{
    *a = *a + *b;
    *b = *a - *b;
    *a = *a - *b;
}



Method 3:

XOR swap


void XORswap(int *a,int *b)
{
    *a = *a ^ *b;
    *b = *a ^ *b;
   *a = *a ^ *b;
}

-->

Which algorithm is efficient for swapping?

SO, which algorithm is efficient for swapping..each algorithm has its own limitations.


In the 2nd method if the addition of the two numbers more than the integer limt, then we can get un expected result.
 XOR swap algorithm is doesn't give right result for the floating point swapping
And also XOR swapping algorithm gives you zero as result if you try to perform swapping on the two variables which contains the same address. So you need to check the address before swapping, like
But the XOR swap is useful in some low memory systems like microcontrollers

void XORswap(int *a,int *b)
{
      if(a==b)
          return;
    *a = *a ^ *b;
    *b = *a ^ *b;
    *a = *a ^ *b;
}


  Finally, swapping using temporary variable is effficient, as todays systems are having more memory.


If you like this article

How to write a UDP socket program in Qt

2012-12-07T17:56:00.000+05:30

We have seen how to write a simple UDP socket program in C (Linux) in the earlier post..

Now we are going to learn how to write a simple UDP socket program in Qt..

In the following example we used to send and receive data on localhost address.
And the readyRead() signal and slot is used whenever the data receives on the given socket (i.e. socket reday for read data), the control goes to slot method.
writeDatagram() and readDatagram() API's used for sending and receiving data on the given udp socket.

Before starting the Program to write, create a Project using following steps

open Qt creator
Create Project
Select Other Project in Projects tab then select Qt Console Application, then click on choose...
Then give the Project name
And then click on Next, Finish in the following dialog boxes
Then open the .pro file and write QT += network
To create the cpp file Right click on the project then choose Add new

myudp.h:

#ifndef MYUDP_H

#define MYUDP_H

#include <QObject>

#include <QUdpSocket>

class MyUDP : public QObject

    Q_OBJECT

public:

    explicit MyUDP(QObject *parent = 0);

    void WriteData();

signals:

public slots:

    void readReady();

private:

    QUdpSocket *socket;

};

#endif // MYUDP_H

myudp.c

#include "myudp.h"

MyUDP::MyUDP(QObject *parent) :QObject(parent)
{
    socket = new QUdpSocket(this);

    socket->bind(QHostAddress::LocalHost,5678);

    connect(socket,SIGNAL(readyRead()),this,SLOT(readReady()));
}

void MyUDP::WriteData()
{
    QByteArray msg;
    msg.append("Hello!!!");

    socket->writeDatagram(msg,QHostAddress::LocalHost,5678);
}

void MyUDP::readReady()
{
    QByteArray buffer;

    buffer.resize(socket->pendingDatagramSize());

    QHostAddress sender;

    quint16 port;

    socket->readDatagram(buffer.data(),buffer.size(),&sender,&port);

    qDebug()<<"Message From: " << sender.toString();

    qDebug()<<"With Port Number " << port;

    qDebug()<<"Message: " << buffer;
}


main.c

#include <QtCore/QCoreApplication>
#include "myudp.h"

int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    MyUDP client;

    client.WriteData();

    return a.exec();
}
-->

Output:

Linux Shell scripting basics and Simple example to add two numbers

2012-11-26T17:08:00.000+05:30

Shell scripting is a file which contains the list of commands for executing. What is Shell? Shell is special program or application provided for the user interaction.

There are different kinds of shells in Unix/Linux, they are

Sh: Bourne Shell
Csh: C Shell
Ksh: Korn Shell
Bash: Bourne again Shell.. etc

Some of the advantages of the shell scripting are,

Automation of tasks such as backups,log monitoring etc
To do repetition of of tasks
Save lots of time..

Unix/Linux Shell scripting also containg the functions, control statements,loops like other programming languages C, C++...

To create a variable, we use the following syntax,

variablename=value
Note: there is no semicolon(;) at the end of each line like other languages

variable name can contain alphabet, digits.Remember Spaces and special characters are not allowed except underscore( _ ) like in other programming languages C,C++.

Comments in the shell script are start with # symbol
To retrieve the value of a variable use $ symbol
To do arithmetic operations use ((expression)) syntax

To start shell scripting program, we need any text editor like vi, vim etc.

Here is the simple Linux Shell Scripting program.

firstscript.sh:

#!/bin/bash

# variable declaration

str="Hello World"

#echo command used to display text

echo "$str"

echo "From DevelopersFactory"

To execute the shell script we should use any of the following methods,

First Method

Give executable permissions to the file

$chmod 0755 filename

Then execute it

$./filename

2nd Method

$sh filename or

$bash filename

Output:

$chmod 0755 firstscript.sh

$./firstscript.sh

Hello World
From DevelopersFactory

The following code snippet will describe arithmetic operations in shell script

 add.sh:

#!/bin/bash

sum=0

echo "enter two numbers"

read a

read b

#we can use any of the following

sum=$(($a+$b))

#sum=`expr $a + $b`

# bc command can calucate accurately with floating point

#here we use division to examine the floating point result

#echo "$a/$b" | bc -l;

echo "sum of the two numbers is $sum"

Output:

$chmod 0755 add.sh

$./add.sh

enter two numbers
3
5
sum of the two numbers is 8

Signal handling in Linux using signal() call

2012-11-12T20:56:00.000+05:30

signal() function in linux is used to sets of handler for the given signal number, the handler is any of SIG_DFL(default action) or SIG_IGN(ignore signal) or address of user defined function which we called signal handler

syntax:

sighandler_t signal(int signum, sighandler_t handler);

the second parameter is the address of the signal handler function (function pointer), which has the following syntax

typedef void (*sighandler_t)(int );

Here the parameter int represents the Signal number.

Here is the simple C program which describes the SIGINT Signal handling in linux

signal.c

#include<stdio.h>

#include<signal.h>

void sig_handler(int signum)

    printf("I'm in INT_SIGNAL handler:%d\n",signum);

int main()

    signal(SIGINT,sig_handler);

    while(1)

        printf("hello i'm in main\n");

        sleep(1);

    return 0;

Output:

$gcc -o signal signal.c

$./signal

hello i'm in main

^CI'm in INT_SIGNAL handler:2

hello i'm in main

^CI'm in INT_SIGNAL handler:2

hello i'm in main

[2]+ Stopped ./signal

Note: to send the SIGINT signal to the process, use shortcut key CTRL+c in the keyboard while program being executed, then our handler will invoked. To stop the program press CTRL+z keys.

Note: to see list of signals in linux system open terminal, then enter the command

$kill -l

gethostbyname example in C

2012-11-08T17:56:00.000+05:30

gethostbyname() function will return the host details such as hostname, aliase names of the host,type of address, and length of host address of the given hostname.

This function will return the hostent (host entry) structure which contain the all the above details. h_addr_list[0] field of “hostent” structure will contain struct in_addr equivalent of the host address.

Sysntax:
struct hostent *gethostbyname(const char *name);

Here name is any valid hostname (or) IPV4 address in standard dot notation (or) IPV6 address in colon or dot notation

Here is the simple C Program in Linux that illustrates the gethostbyname() function.
hostinfobyname.c

-->

#include<stdio.h>

#include<stdlib.h>

#include<unistd.h>  //for gethostname()

#include<netinet/in.h>

#include<arpa/inet.h> // for inet_ntoa()

#include<netdb.h> // for hostent structure, gethostbyname()

#include<string.h>

int main(int argc,char *argv[])

 char *hname,**aliases,**address;

 struct hostent *hostinfo;

 struct in_addr ipadd;

 if(argc == 1) {

  char myname[256];

  gethostname(myname,255);

  hname = myname;

  //printf("host name %s",hname);

 else {

  hname = argv[1];

 hostinfo = gethostbyname(hname);

 if(!hostinfo) {

  fprintf(stderr, "can not get info for the HOST %s\n",hname);

  exit(1);

 printf("Result for Host %s \n",hname);

 printf("Host name: %s \n",hostinfo->h_name);

 printf("Aliases: ");

 aliases = hostinfo->h_aliases;

 while(*aliases)  {

  printf("%s ",*aliases);

  aliases++;

 printf("\n");

 if(hostinfo->h_addrtype != AF_INET) {

  fprintf(stderr," Not a IP host \n");

  exit(1);

 printf("Type: %s\n",hostinfo->h_addrtype==AF_INET? "AF_INET" : "AF_INET6");

 printf("Length of addrs in bytes : %d \n",hostinfo->h_length);

 printf("Address list: ");

 address = hostinfo->h_addr_list;

 while(*(address)) {

  printf("%s ",inet_ntoa(*(struct in_addr *)*address));

  address++;

 ipadd=*(struct in_addr *)hostinfo->h_addr_list[0];

 printf("\n");

 printf("IP Address: %s\n",inet_ntoa(ipadd));

return 0;

Output:
$gcc -o hostinfo hostinfobyname.c
$./hostinfo

Result for Host developersFactory-LAP08
Host name: developersFactory-LAP08
Aliases:
Type: AF_INET
Length of addrs in bytes : 4
Address list: 127.0.1.1
IP Address: 127.0.1.1

UDP Client Server C Program

2012-11-03T20:56:00.000+05:30

Hii all, in this Post you will learn how to write a simple UDP Socket Program in C in linux to send a message to the server and server will reply you.
Unlike TCP, UDP does not have connection establishment.So there is no connet() system call in client and accept() systemcall in server.

So the System calls in the server are
1.socket()
2.bind()
3.recvfrom()
4.sendto(
and I client the system calls are
1.socket()
2.sendto()
3.recvfrom()

The simple UDP Client-Server Program is as follows

udp_server.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<errno.h>
#define MAXSIZE 512
#define MYPORT 5608

int main()
{
int sockfd,len,ret,numbytes;
struct sockaddr_in saddr,caddr;
char recvbuf[MAXSIZE],sendbuf[MAXSIZE];

sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0) {
printf("soket: %s\n",strerror(errno));
return -1;
}

saddr.sin_family = AF_INET;
saddr.sin_port = htons(MYPORT);
saddr.sin_addr.s_addr = INADDR_ANY;
len = sizeof(struct sockaddr);

ret = bind(sockfd,(struct sockaddr *)&saddr,len);
if(ret == -1) {
printf("bind server: %s\n",strerror(errno));
return -1;
}

while(1) {
printf("UDP Server Waiting for Client\n");
numbytes = recvfrom(sockfd,recvbuf,sizeof(recvbuf),0,(struct sockaddr *)&caddr,&len);
if(numbytes == -1)
printf("recv error: %s\n",strerror(errno));
else
{
recvbuf[numbytes] = '\0';
printf("Message received from client [%s :%d]:",inet_ntoa(caddr.sin_addr),ntohs(caddr.sin_port));
printf("%s\n",recvbuf);
}

strcpy(sendbuf,"hai");
numbytes = sendto(sockfd,sendbuf,sizeof(sendbuf),0,(struct sockaddr *)&caddr,len);
if(numbytes == -1)
printf("send error: %s\n",strerror(errno));
}
return 0;
}

udp_client.c

#include<stdio.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<string.h>
#include<errno.h>
#define MAXSIZE 512
#define MYPORT 5608
#define ADDR "127.0.0.1"

int main()
{
int sockfd,len,ret,numbytes;
struct sockaddr_in saddr;
char sendbuf[MAXSIZE],recvbuf[MAXSIZE];

sockfd = socket(AF_INET,SOCK_DGRAM,0);
if(sockfd < 0) {
printf("soket: %s\n",strerror(errno));
return -1;
}

saddr.sin_family = AF_INET;
saddr.sin_port = htons(MYPORT);
saddr.sin_addr.s_addr = inet_addr(ADDR);
len = sizeof(struct sockaddr);
strcpy(sendbuf,"hello");
numbytes = sendto(sockfd,sendbuf,sizeof(sendbuf),0,(struct sockaddr *)&saddr,len);
if(numbytes == -1)
printf("Send error: %s\n",strerror(errno));
else
printf("Message %s sent Successfully to [%s :%d]:\n",sendbuf,inet_ntoa(saddr.sin_addr),ntohs(saddr.sin_port));

numbytes = recvfrom(sockfd,recvbuf,sizeof(recvbuf),0,(struct sockaddr*)&saddr,&len);
if(numbytes == -1)
printf("receive error: %s\n",strerror(errno));
else
printf("Data Received from server: %s\n",recvbuf);

return 0;
}

Output:
How to Compile and Run?
open two terminals and in
Terminal1 Terminal2

$gcc -o server udp_server.c $gcc -o client udp_client.c
$./server $./client

Result:
Terminal1:
UDP Server Waiting for Client
Message received from client [127.0.0.1 :46342]:hello
UDP Server Waiting for Client

Terminal2:
Message hello sent Successfully to [127.0.0.1 :5608]:
Data Received from server: hai

C program for getting Linux system information

2012-10-19T21:26:00.000+05:30

In most of the Linux systems we use the command “uname” to print the system information in the terminal.

Ex:

$uname -a

which gives the information about the system such as OS name, kernel version, release,domain name etc... Similerly we can get that information through C Programming.

Now I will let you how to print Linux system information through C programming in Linux, by using the structure “struct utsname”, and the system call uname() which return 0 on success, -1 on error.. See the code snnippet given below...

uname.c:

#include<stdio.h>

#include<sys/utsname.h>

int main()

{

int ret;

struct utsname buf;

ret = uname(&buf);

if(!ret) {

printf("OperatingSystem name: %s\n",buf.sysname);

printf("Node(Host) name: %s\n",buf.nodename);

printf("Kernel Release Version: %s\n",buf.release);

printf("OS Version: %s\n",buf.version);

printf("Hardware: %s\n",buf.machine);

}

else {

printf("Error in the System call");

return -1;

}

return 0;

}

OUTPUT:

OperatingSystem name: Linux

Node(Host) name: SAI-LAP

Kernel Release Version: 3.2.0-32-generic-pae

OS Version: #51-Ubuntu SMP Wed Sep 26 21:54:23 UTC 2012

Hardware: i686

Note: We can also access these details through /proc/sys/kernel directory, for example

$cat /proc/sys/kernel/ostype

which gives Operating system type...similerly we can get osrelease,hostname,version,domainname (replace “ostype” with any of these).

QGraphicsView Example Program by inheriting QGraphicsView class

2012-10-04T06:26:00.000+05:30

In the prevoius qgraphicsview example we created the view (QgraphicsView) and placed the scene in this view.Now in this example we created a class and inherit this class from QGraphicsView class, so the class being inherited acts like view and we will set the scene for this inherited class.

Check the example program and the output below...

graphics.h

#ifndef GRAPHICS_H
#define GRAPHICS_H
#include <QtGui/QWidget>
#include <QGraphicsEllipseItem>
#include <QGraphicsScene>
#include <QGraphicsView>
class graphics : public QGraphicsView
{
    Q_OBJECT
    QGraphicsScene *scene;
    QGraphicsEllipseItem *itm_ellipse;
    QGraphicsTextItem *itm_txt;
    QGraphicsLineItem *itm_line;
    QGraphicsPolygonItem *itm_poly;
    
public:
    graphics(QWidget *parent = 0);
    ~graphics();
};
#endif // GRAPHICS_H

graphics.cpp

#include "graphics.h"
graphics::graphics(QWidget *parent)
    : QGraphicsView(parent)
{
    scene = new QGraphicsScene(this);    scene->setSceneRect( -300,-300,600,600 );
    this->setScene(scene);

    itm_ellipse = new QGraphicsEllipseItem(0,scene );
    itm_ellipse->setRect( -100.0, -100.0, 100.0, 100.0 );
    itm_ellipse->setFlag(QGraphicsItem::ItemIsMovable);


    itm_txt = new QGraphicsTextItem("hello",0,scene);
    itm_txt->setPos(100,100);

    itm_line = new QGraphicsLineItem(0,0,100,100,0,scene);

    itm_poly = new QGraphicsPolygonItem(0,scene);
    QPolygonF poly;
    poly<<QPoint(100,100)<<QPoint(200,100)<<QPoint(200,200)<<QPoint(100,200);
    itm_poly->setPolygon(poly);
}


graphics::~graphics()
{
    
}

main.cpp

#include <QtGui/QApplication>
#include "graphics.h"
int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    graphics w;
    w.show();
    
    return a.exec();
}

Output:

QgraphicsView simple example program

2012-10-01T05:38:00.000+05:30

Here is a simple QgraphicsView example program in Qt.

In this example we created a scene (QGraphicsScene) and placed all the items  in this scene by specifying the scene object while creating the graphics item.Andat last we created the view (QGraphicsView) and scene is placed in this view by using setScene() method of QgraphicsView.

#include <QtGui/QApplication>

#include<QGraphicsView>

#include<QGraphicsScene>

#include<QGraphicsSimpleTextItem>

#include<QGraphicsRectItem>

#include<QGraphicsEllipseItem>

#include<QVector>

#include<QGraphicsPolygonItem>

int main( int argc, char **argv )

    QApplication app( argc, argv );

    QGraphicsScene scene( QRect( -100, -100, 400, 400 ) );

    scene.setBackgroundBrush(Qt::cyan);

    QGraphicsSimpleTextItem *textItem = new QGraphicsSimpleTextItem(

                "technoyouth10", 0, &scene );

    textItem->setPos( -50, -50 );

    textItem->setFlag(QGraphicsItem::ItemIsMovable);

    QGraphicsRectItem *rectItem = new QGraphicsRectItem(

                QRect( 0, -0, 200, 40 ), 0, &scene );

    rectItem->setPen( QPen( Qt::red, 3, Qt::DashDotLine ) );

    rectItem->setBrush( Qt::green );

    QGraphicsEllipseItem *ellipseItem = new QGraphicsEllipseItem(

                QRect( 80, -80, 100, 75 ),

                0, &scene );

    ellipseItem->setPen( QPen(Qt::yellow) );

    ellipseItem->setBrush( Qt::magenta );

    QVector<QPointF> points;

    points << QPointF( 20, 50 ) << QPointF( 80, 50 ) << QPointF( 110, 80 )

           << QPointF( 50, 130 )<< QPointF( -10, 80 ) ;

    QGraphicsPolygonItem *polygonItem = new QGraphicsPolygonItem(

                QPolygonF( points ), 0, &scene );

    polygonItem->setPen( QPen(Qt::red) );

    polygonItem->setBrush( Qt::yellow );

    QGraphicsView view;

    view.setScene( &scene );

    view.show();

    return app.exec();

Output:

Run the program by pressing Ctrl+r...

TCP Daytime client Program using C in linux

2012-08-18T06:26:00.012+05:30

This is the client program to get the time and date. Daytime server is the server program which is provided by the linux, and it has a specific name in the system i.e. "daytime".

daytimecli.c

#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<netdb.h>

int main(int argc,char *argv[])
{
    int sockfd,len,ret;
    struct sockaddr_in saddr;
    char *hname,buff[256];
    struct hostent *hostinfo;
    struct servent *servinfo;
   if(argc == 1)
        hname = "localhost";
    else
        hname = argv[1];

    hostinfo = gethostbyname(hname);
    if(!hostinfo) {
        fprintf(stderr,"No host: %s\n ",hname);
        exit(1);
    }

    servinfo = getservbyname("daytime","tcp");
    if(!servinfo) {
        fprintf(stderr,"No day time server \n");
        exit(1);
    }
    printf("Day time server Port: %d\n", ntohs(servinfo->s_port));

    // creating tcp socket
    sockfd = socket(AF_INET,SOCK_STREAM,0);
    saddr.sin_family = AF_INET;
    saddr.sin_port = servinfo->s_port;
    saddr.sin_addr = *(struct in_addr *) *(hostinfo->h_addr_list);
    len = sizeof(saddr);

    ret = connect(sockfd,(struct sockaddr *)&saddr,len);
    if(ret == -1) {
        perror("connect ");
        exit(1);
    }

    ret = read(sockfd,buff,sizeof(buff));
    buff[ret] = '\0';
    printf("Result: %s and %d bytes read\n",buff,ret);

    close(sockfd);

return 0;
}

output:

$gcc -o daytimecli daytimecli.c
$./daytimecli

o/p

Day time server Port: 13
connect : Connection refused

You may get output like this, because your daytime server port is not in active state to receive request. To get enable daytime server port on Click Here and follow procedure.

The Output will be as after enable daytime server

$gcc -o daytimecli daytimecli.c
$./daytimecli
o/p
Day time server Port: 13
Result: 17 AUG 2012 17:56:08 IST
and 26 bytes read

Simple Client-Server network Program using TCP/IP stream sockets

2012-08-02T21:52:00.000+05:30

This is a simple socket program, in which client sends a message to the server and server replies to the client. The server is waiting for the client process connections.

Server Program:
server.c

#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<netinet/in.h> // for networkbyte order (htons(),htonl())
#include<arpa/inet.h>
#include<string.h>
#include<unistd.h>

int main()
{
    struct sockaddr_in saddr,caddr;
    int len,listenfd,sessfd,ret,retb;
    char buff[10]={0};

    listenfd = socket(AF_INET,SOCK_STREAM,0);
    if(listenfd == -1) {
        perror("socket ");
        return -1;
    }

    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    saddr.sin_port = htons(5678);
    len = sizeof(saddr);

    retb=bind(listenfd,(struct sockaddr *) &saddr, len);
    if(retb == -1) {
        perror("bind ");
        return -1;
    }


    listen(listenfd,5);

    while(1) {
        printf("Server Waiting...\n");
        sessfd = accept(listenfd,(struct sockaddr *)&caddr,&len);
        if( sessfd< 0 ) {
            perror("accept: ");
            return -1;
        }
        read(sessfd,&buff,sizeof(buff));

        printf("server read: %s \n",buff);
        memset(buff,'\0',sizeof(buff));
        strcpy(buff,"hai user");
        write(sessfd,&buff,sizeof(buff));


        close(sessfd);
    }
    close(listenfd);
return 0;
}

Client Program:

   client.c
#include<sys/types.h>
#include<sys/socket.h>
#include<stdio.h>
#include<netinet/in.h> // for networkbyte order (htons(),htonl())
#include<arpa/inet.h>
#include<string.h>
#include<unistd.h>

int main()
{
    struct sockaddr_in saddr;
    int len,sockfd,ret;
    char buff[10]="hello";

    sockfd = socket(AF_INET,SOCK_STREAM,0);
    if(sockfd == -1) {
        perror("socket: ");
    }

    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
    saddr.sin_port = htons(5678);

    len = sizeof(saddr);

    ret = connect(sockfd,(struct sockaddr *)&saddr,len);
    if(ret <0 ) {
        perror("connect: ");
        return -1;
    }
    write(sockfd,&buff,sizeof(buff));
    memset(buff,'\0',sizeof(buff));
    read(sockfd,&buff,sizeof(buff));

    printf("Client Read: %s\n",buff);

    close(sockfd);
return 0;
}