RTV Studios

Saturday, 5 March 2016

auto and decltype in C++11 and C++14

C++11 and C++14 compiler helps you to find out the type of a variable, function with the introduciton of auto. auto works similar to var in C#.

auto with declarations

So instead of declaring

    int x = 10;

you can declare

    auto x = 10;

Can we use auto without initialization? No. In this case compiler will not be able to deduce the type of the variable.

Can we use auto with class member variable? Only where you can initialize the member variable; static constants. So the below shown declaration is valid.

    class Test
    {
    public:
        static const auto x = 4;
    };

auto with functions

In C++11

Another place where we can use auto is with function return type. But there is a catch in using auto with return type. If you just use as shown below things will not work,

    auto add(int x, int y) {
        return x+y;
    }

You can definitely use auto in place of function return type, if you change the function to as shown below,

    auto add(int x, int y) -> int {
        return x+y;
    }

This doesn't look like too interesting, isn't it; it is just that we are specifying the return type in a different place. We will see some use of having auto with function declaration in c++11 in below sections

In C++14

In C++14 the first version of add function defined above will work fine.

What if we have multiple return statement with different types? you will get a compilation error. So the following function will give you compilation error.

auto factorial(int n) 
{
    if (n == 1) {
        return int(1);
    }
    if (n == 2) {
        return long(2);
    }

    int res = 1;
    for (; n>0; --n) {
        res *= n;
    }

    return res;
}

What about the following recursive function?

auto factorial(int n) 
{
    if (n > 1) {
        return factorial(n-1) * n;
    }

    return 1;
}

Another compilation error. It is not allowed to call recursive function call before a return statement.
So change the function slightly as shown below and everything should start working.

auto factorial(int n) 
{
    if (n == 1) {
        return 1;
    }
    return factorial(n-1) * n;
}

In c++14 you can also make function parameter auto, the below given version of factorial works just fine in c++14.

auto factorial(auto n)
{
    if (n == 1) {
        return 1;
    }
    return factorial(n-1) * n;
}

decltype

Let me introduce another feature, decltype, and see if the auto in function return type has any benefit or not.
decltype helps to get the type of a variable or expression, one use of it is shown below,

    float a = 1.0f;
    decltype(a) b = a;

Ok so we have got another way to declare variable. We can use auto as well in this case, what benefit does decltype brings?
Now lets go back the function that we declared and see if we can use decltype there, maybe we can. Modified function is shown below,

    auto add(int x, int y) -> decltype(x) {
        return x+y;
    }

Another interesting thing about decltype is that we can also give expression with it. The following code snippet works really well and the return type will be float.

    auto add(float x, int y) -> decltype(x+y) {
        return x+y;
    }

Like sizeof operator the expression in decltype will not be getting evaluated. So the following program will output 1,1.

    #include <iostream>

int main(int argc, char **argv) {
    int x = 1;
    decltype(++x) y = x;
    std::cout << x << "," << y<< std::endl;
}

auto with reference

Now lets see how auto works with references, can you guess what is the output of the following code block?

#include <iostream>
    
int & incr(int &x)
{
    return ++x;
}

int main(int argc, char **argv) {
    int x = 1;
    auto y = incr(x);
    ++y;
    std::cout << x << std::endl;
}

It is 2 not 3. auto type by default takes the value not reference. Change the declaration as shown below and everything should work as expected.

    auto & y = incr(x);

Then what about pointers?auto works as expected, it is not necessary to specify as auto *

decltype(auto) - c++14

The above code can be made to work as expected using decltype(auto), It takes the type from the initialization

#include <iostream>

int & incr(int &x)
{   
    return ++x;
}   

int main(int argc, char **argv) {
    int x = 1;
    decltype(auto) y = incr(x);
    ++y;
    std::cout << x << std::endl;
}

Output of the above program is 3.

Now lets change the function incr function by using auto as shown below and lets see what happens.

#include <iostream>

auto incr(int &x)
{   
    return ++x;
}   

int main(int argc, char **argv) {
    int x = 1;
    decltype(auto) y = incr(x);
    ++y;
    std::cout << x << std::endl;
}

Now the output is 2.

How do we fix this to make the behaviour same as that of the first program? One way is to use decltype(auto) with function as shown below,

#include <iostream>

decltype(auto) incr(int &x)
{   
    return ++x;
}   

int main(int argc, char **argv) {
    int x = 1;
    decltype(auto) y = incr(x);
    ++y;
    std::cout << x << std::endl;
}

Please visit http://blog.trsquarelab.com/2015/05/compiling-c11-and-c14-programs-with-gcc.html for information on how to compile with C++11 and C++14 support in Ubuntu using GCC

lambda expression in C++11 and C++14

Lambda expressions are available from C++11 onwards.

The simplest of the lambda expression is

[] {};

which does nothing.

The syntax of a lambda expression is,

[ /*capture-list*/ ] ( /*params*/ ) mutable /* optional*/ /*exception*/ /*attribute*/ -> /*return type*/ { /*body*/ }

capture-list	list of comma separated captures
params	list of comma separated parameters
mutable	allows body to modify parameters captured by value
exception	exception specifications
attribute	attribute specifications

You can think of lambda expression as a functor. For easy understanding you can imagine that the lambda expression is implemented as some thing like,

class ClosureType
{
    /* members variables are identified using capture list */
public:
    ClosureType(/*capture list*/)
    {}

    /* non-mutable lambda */
    return-type operator(/* parameter list*/) const {/*body*/}

    /* mutable lambda */
    return-type operator(/* parameter list*/) {/*body*}
};

Simple examples

The following code snippet will print Hello from Lambda

[]{
    std::cout << "Hello from Lambda" << std::endl;
}();

Capture list

To access variables declared outside the lambda expression you can use capture list.

int n = 10;

[n]{
    std::cout << "n = " << n << std::endl;
}();

Capturing all automatic variables,

int n = 10;
int m = 20;

[=]{
    std::cout << "n = " << n << " m = " << m << std::endl;
}();

No need to capture global variables, they are accessible in lambda expressions. The above method access variables by value.

To access by reference use & as shown below,

    int n = 10;
    int m = 20;

    [n, &m]{
        std::cout << "n = " << n;
        m = 10;
    }();


    std::cout << " m = " << m << std::endl;

Output of the above program is n = 10 m = 10

Just as we done earlier use just & to access all automatic variables by reference.

this variable can be accessed in the lambda expressions if we add this in the capture list as [this].

capture expressions - C++14

C++14 allows captured members to be initialized with arbitrary expressions. A simple example would be,

auto l = [v = 1] {std::cout << v; };
l();

We can also use reference in the expression as,

int y;
[&x = y]{}

Parameters

Paremeters can be specified as you would do for a function. For example the following code will output 1, 2

auto l = [] (int a, int b) {std::cout << a << " " << b; };
l(1, 2);

Can I use template like I do with function? No. But in C++14 you can use auto for parameters as shown below,

auto l = [] (auto a) {std::cout << a ; };
l(1);

Return value

If you do not specify any return type will be deduced from the return statement,

auto increment = [] (int i) {return ++i;};
std::cout << increment(1) << std::endl;

The above code can also be declared as,

auto increment = [] (int i) ->int {return ++i;};
std::cout << increment(1) << std::endl;

We can also use decltype in return type.

auto increment = [] (int i) ->decltype(i) {return ++i;};
std::cout << increment(1) << std::endl;

In C++14 the return type can also be auto

Recursive lambda expression

We can also have recursion with lambda expression. In this case we cannot use auto to store lambda variable, but fill have to use std::function. An example is shown below,

#include <iostream>
#include <functional>

std::function<int(int)> factorial = [] (int n) -> int {
    if (n <= 1) {
        return 1;
    }

    return factorial(n-1) * n;
};

int main(int argc, char ** argv)
{
    std::cout << factorial(4) << std::endl;
    return 0;
}

Nested lambda expression

Lambda expression can also be nested.

#include <iostream>

int main(int argc, char ** argv)
{
    int i = 1;

    auto outer = [=] {
        int j = 2;
        auto inner = [=] {
            std::cout << "inner : " << i << " " << j;
        };
        inner();
        std::cout << "outer : " << i << " " << j;
    };

    outer();

    return 0;
}

Output of the above program is inner : 1 2outer : 1 2

Lambda expression as function parameter

There are many ways of declaring function which takes lambda expression as parameter, some of them are shown below.

#include <iostream>
#include <functional>

void func1(std::function<void(std::string const &)> const & l)
{
    l("from func1");
}

template <typename T>
void func2(T l)
{
    l("from func2");
}

// if C++14 is supported
#if __cplusplus > 201103L
void func3(auto l)
{
    l("from func3");
}
#endif

int main(int argc, char **argv)
{
    auto l = [] (std::string const & msg) {
                    std::cout << msg << std::endl;
                };

    func1(l);
    func2(l);

#if __cplusplus > 201103L
    func3(l);
#endif

    return 0;
}

Function returning lambda expression

Examples for function returning lambda expressions are given below,

#include <iostream>
#include <functional>

std::function<void()> func1()
{
    return [] {
                std::cout << "from func1" << std::endl;
              };
}

// In C++14 you don't have to specify return type
auto func2() -> std::function<void()>
{
    return [] {
                std::cout << "from func2" << std::endl;
              };
}

int main(int argc, char **argv)
{
    func1()();
    func2()();

    return 0;
}

Dangling reference

We have to make sure that the variables captured using reference is alive (life time is not ended).
As an example the below given programme has an illegal memory access. It is trying to access variable i after its life time is over.

#include <iostream>
#include <functional>

std::function<void()> func()
{
    int i = 10;
    return [&] {
                std::cout << i << std::endl;
              };
}

int main(int argc, char **argv)
{
    func()();

    return 0;
}

Sizeof lambda expressions

Size of lambda expressions might vary according to the compiler. If the lambda expression does not capture any variables then its size will mostly be 1. If it captures variables the size of lambda expression will the total size of the variables it captured. The output of the below program when compiled with gcc is 1 8.

#include <iostream>

int main(int argc, char ** argv)
{
    int i = 1;
    int j = 2;

    auto l1 = [] {
        std::cout << "l1";
    };

    auto l2 = [=] {
        std::cout << "l2 : " << i << j;
    };

    std::cout << sizeof(l1) << " " << sizeof(l2) << std::endl;

    return 0;
}

Please visit http://blog.trsquarelab.com/2015/05/compiling-c11-and-c14-programs-with-gcc.html for information on how to compile with C++11 and C++14 support in Ubuntu using GCC

multi-threaded programming in C++11

This page is more on examples of multi-thread programming in c++11 than a reference.

Creating thread

A new thread can be created using std::thread class. An example is shown below on how to create a thread.

#include <thread>
#include <iostream>

void run() 
{
    std::cout << __FUNCTION__ << std::endl;
}

int main(int argc, char **argv) {
    std::thread t(run);

    t.join();
}

The above example create a thread t which executes the run function it the new thread.
If we do not create any thread there will always be one thread in the application, we usually call it the main thread.Now suppose we are creating a new thread then the main thread and the newly created thread will execute in parallel. In our example above thread object t is created in main thread and it will be out of scope once main thread finish executes main function and terminate will be called, even if the newly created thread is active. To avoid this we need to make our main thread wait for the newly created thread to complete its execution. The way to do that is to call t.join();

Important functions in std::thread

get_id	Retrieves thread thread id
joinable	Checks if the thread is joinable
join	Joins the thread, ie. wait for the thread to complete its execution
detach	Detach thread
swap	Swap thread objects

Using Mutex

Mutex can be used to protect data from multiple threads. mutex::lock can be used to prevent multiple thread access to shared data and mutex::unlock to release the lock.
An example of using std::mutex is shown below,

#include <thread>
#include <mutex>
#include <chrono>
#include <vector>
#include <memory>
#include <iostream>

void run()
{
    static std::mutex m;

    // only one thread at a time so that both
    // of the print outs happens one after another
    m.lock();

    std::cout << __FUNCTION__ << " started" << std::endl;

    // wait for 100 milli seconds
    std::this_thread::sleep_for(std::chrono::milliseconds(100));

    std::cout << __FUNCTION__ << " ended" << std::endl;

    m.unlock();
}

int main(int argc, char **argv) {
    std::vector<std::shared_ptr<std::thread> > threads;

    for (int i=0; i<5; ++i) {
        std::shared_ptr<std::thread> t(new std::thread(run));
        threads.push_back(t);
    }

    for (std::shared_ptr<std::thread> t : threads ) {
        t->join();
    }
}

Important functions in std::mutex

lock	locks the mutex
unlock	unlock the mutex
try_lock	try locking the mutex, returns if the mutex is already locked

Condition Variable

Condition variable is a synchronization primitive that allows a thread to wait until a condition occurs.

As a simple example, lets take the first example and make it work without using join function.

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>

std::condition_variable cv;
std::mutex m;

void run() {
    std::cout << __FUNCTION__ << " entered" << std::endl;

    // lets put a small delay
    for (int i=0; i<5; ++i) {
        std::cout << "." << std::flush;
        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
    std::cout << std::endl;

    std::cout << __FUNCTION__ << " exiting" << std::endl;

    // notify once we are done with the thread execution
    std::unique_lock<std::mutex> l(m);
    cv.notify_one();
}

int main() {
    std::thread t(run);
    t.detach();

    // wait for the thread to finish, once the thread execution is complete it will be notified 
    std::unique_lock<std::mutex> l(m);
    cv.wait(l);
    
    return 0;
}

Important functions in std::condition_variable

wait	wait for notification
notify_one	notify one waiting thread
notify_all	notify all waiting thread

Now lets see some example of multi thread programming.

Printing 1 to 10 from two thread.

Lets print 1 to 10 with odd numbers printed in one thread and even from the other thread.

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>

// mutex used with condition variables
std::mutex evenMutex;
std::mutex oddMutex;

// condition variables
std::condition_variable evenCV;
std::condition_variable oddCV;

void evenThread()
{
    for (int i=2; i<11; i+=2) {
        // wait for the odd thread to print the value and notify this thread
        {
            std::unique_lock<std::mutex> l(oddMutex);
            oddCV.wait(l);
        }

        std::cout << i << std::endl;

        // notify the odd thread to print value
        std::unique_lock<std::mutex> el(evenMutex);
        evenCV.notify_one();
    }
}

void oddThread()
{
    for (int i=1; i<10; i+=2) {
        std::cout << i << std::endl;

        // notify the even thread to print the value
        {
            std::unique_lock<std::mutex> ol(oddMutex);
            oddCV.notify_one();
        }

        // wait for the even thread to print the value
        std::unique_lock<std::mutex> el(evenMutex);
        evenCV.wait(el);
    }
}

int main(int argc, char **argv)
{
    std::thread ot(oddThread);
    std::thread et(evenThread);

    ot.join();
    et.join();

    return 0;
}

Thread pool

Lets create a thread pool which creates a given number of threads and distributes the work in one of the available thread. If no thread is available it will wait for a thread to finish.

#include <iostream>
#include <mutex>
#include <thread>
#include <condition_variable>
#include <atomic>
#include <vector>
#include <queue>
#include <memory>

class ThreadPool;

// worker class. It will create a thread and wait for a task from the ThreadPool
class Worker {
    std::thread mThread;
    std::atomic_bool mFinished;
    ThreadPool *mPool;

public:
    Worker(ThreadPool *pool)
     : mFinished(false),
       mPool(pool) {
        create();
    }

    ~Worker() {
        join();
    }

    void join() {
        if (mThread.joinable()) {
            mThread.join();
        }
    }

    void terminate() {
        mFinished = true;
    }

    void create();

private:
    void doCreate();
};

class ThreadPool {
private:
    int mWorkerCount;
    // worker vector
    std::vector<std::shared_ptr<Worker>> mThreads;

    // work quueue is a queue of lambda functions
    std::queue<std::function<void(void)>> mWorkQueue;

    // lock used to synchronize queue access and update
    std::mutex mWorkQueueLock;

    // condition variable used to notify task availability
    std::mutex mNotifierLock;
    std::condition_variable mNotifier;

    // condition variable used to notify termination of thread pool
    std::mutex mTerminateLock;
    std::condition_variable mTerminateCV;

public:
    ThreadPool(int workerCount)
     : mWorkerCount(workerCount) {
        create();
    }

    ~ThreadPool() {
        // wait for the termination of the pool
        std::unique_lock<std::mutex> tl(mTerminateLock);
        mTerminateCV.wait(tl);
    }

    void terminate() {
        for (std::shared_ptr<Worker> t: mThreads) {
            t->terminate();
        }
        std::unique_lock<std::mutex> tl(mTerminateLock);
        mTerminateCV.notify_one();
    }

    void submitWork(std::function<void()> const & work) {
        // add task to queue
        {
            std::unique_lock<std::mutex> ql(mWorkQueueLock);
            mWorkQueue.push(work);
        }

        // notify availability of task
        std::unique_lock<std::mutex> nl(mNotifierLock);
        mNotifier.notify_one();
    }

    std::function<void()> getWork() {
        // wait for a task
        waitForWork();

        {
            // retrieve a work
            std::unique_lock<std::mutex> ql(mWorkQueueLock);
            std::function<void()> work = mWorkQueue.front();
            mWorkQueue.pop();
            return work;
        }
    }

private:
    void waitForWork() {
        // wait until queue is not empty
        std::unique_lock<std::mutex> nl(mNotifierLock);
        mNotifier.wait(nl, [this] {
            std::unique_lock<std::mutex> ql(mWorkQueueLock);  return !mWorkQueue.empty();
        });
    }

    void create() {
        for (int i=0; i<mWorkerCount; ++i) {
            mThreads.push_back(std::shared_ptr<Worker>(new Worker(this)));
        }
    }

};

void Worker::create() {
    mThread = std::thread([this] {
        doCreate();
    });
}

void Worker::doCreate() {
    while (!mFinished) {
        mPool->getWork()();
    }
}

int main(int argc, char **argv) {
    ThreadPool pool(2);

    pool.submitWork([]{std::cout << "**work1**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });
    pool.submitWork([]{std::cout << "**work2**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });
    pool.submitWork([]{std::cout << "**work3**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });
    pool.submitWork([]{std::cout << "**work4**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });
    pool.submitWork([]{std::cout << "**work5**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });
    pool.submitWork([]{std::cout << "**work6**" << std::endl; std::this_thread::sleep_for(std::chrono::seconds(1)); });

    return 0;
}

Advanced Android Interview Questions and Answers 3

(PREVIOUS (Advanced Android Interview Questions and Answers 2


Gin Rummy	Indian Rummy	Nine Men's Morris and more	Air Attack

Pages

Saturday, 5 March 2016

auto with declarations

auto with functions

In C++11

In C++14

decltype

auto with reference

decltype(auto) - c++14

Simple examples

Capture list

capture expressions - C++14

Parameters

Return value

Recursive lambda expression

Nested lambda expression

Lambda expression as function parameter

Function returning lambda expression

Dangling reference

Sizeof lambda expressions

Creating thread

Important functions in std::thread

Using Mutex

Important functions in std::mutex

Condition Variable

Important functions in std::condition_variable

Printing 1 to 10 from two thread.

Thread pool

1. How to verify that there is an activity available that can respond to the intent?

2. How to get result from an Activity?

3. What is the use of android:sharedUserId?

4. How to convert an Android application project to an Android library project with gradle build system?

5. What is the purpose of running zipalign?

6. What is the purpose of running ProGuard?

7. What is lint tool?

8. What is multiple APK support in Google play

9. What is the current size limit for an application in Google play?

10. How to upload apks with a size of more than that is mentioned above?

11. What is Support Library?

12. What is DDMS?

13. What is the differece between Serializable and Parcelable?

14. What are the different ways to store data?

15. What are different ways to process a task in a background thread(other than main(UI) thread) in Android?

16. What is data binding?

17. What causes an ANR?

18. In which thread does an IntentService performs it's task?

19. What is doze mode?

20. What is App Standby?

1. What is the architecture of Android?

2. How many ways are there to create a bound service?

3. What are the steps to create a Bound service using AIDL?

4. Will calling finish() on an Activity calls all the usual activity life cycle method?

5. Should base Activity class's onCreate should be called from your Activity implementation?

6. What is the activity life cycle?

7. What is the Fragment life cycle?

8. How to programmatically add fragment to an existing ViewGroup?

9. What are the steps to implement Loader?

10. What are the two types on Intents?

11. What is a content provider?

12. What are the advantages of AsyncTaskLoader over AsyncTask?

13. How many threads are there to service AsyncTask jobs?

14. What are the levels in the importance hierarchy for an Android process?

15. What is reactive programming?

16. How to cancel an AsyncTask?

17. What are the two types of services?

18. In which thread does a Started or Bounded service run?

19. Can a service run in the foreground?

20. What is Retrolambda?

Wednesday, 2 March 2016

Dependency

Implementation

Saturday, 27 February 2016

Dependency

Navigation View

Collapsing Toolbars

Floating Action Button

Snackbar