# Introduction

***

## Who should read this book ?

Effective C++ is one of the best book for improving C++ programs and designs by using C++ best practices. And this book is recommended to every one pursuing career as a C++ developer, So I am writing down this short summary for my own personal use to have a short and to the point summary of the book for future use.

## Terminologies used in this book.

***

#### Declaration

A *Declaration* tells compiler about the name and type of something, but it omits certain details. For Example:

```cpp
extern int size;                         // object declaration
std::size_t numDigits(int number);       // function declaration
class Widget;                            // class declaration
template<typename T> class GraphNode;    // template delaration
```

#### Signature

Each function's declaration reveals its *signature* i.e. its parameter and return types. A function's signature is the same as its types. In the case of `numDigits`, the signature is `size_t(int)`, i.e. "Function taking an `int` and returning `std::size_t`."

#### Definition

A *definition* provides compilers with details a declaration omits. For an object, the definition is where compilers set aside memory for the object. For a function or a function template, the definition provides the code body. For a class or a class template, the definition lists the members of the class or template:

```cpp
int x                                   //  object definition

std::size_t numDigits(int number)       //  function definition
{
  std::size_t digitsSoFar = 1;
  while ((number /= 10) != 0)
    ++digitsSoFar;
  return digitsSoFar
}

class Widget                            //  class definition
{
public:
  Widget();
  ~Widget();
  .....
};

template<typename T>                    //  template definition
class GraphNode
{
public:
  GraphNode();
  ~GraphNode();
  .....
};
```

#### Initialization

*Initialization* is the process of giving an object its first value. For objects generated from structs and classes, initialization is performed by constructors.

#### Default Constructors

A *Default Constructor* is one the can be called without any arguments. Such a constructor has no parameters or has a default value for every parameter:

```cpp
class A
{
public:
  A();                                      // default constructor
};

class B
{
public:
  explicit B(int x=0, bool b=true);         //  default constructor
};

class C
{
public:
  explicit C(int x);                        //  not a default constructor
};
```

The constructor for `class B` and `class C` are declared **`explicit`** here. That prevent them from being used to perform implicit type conversions, though they may still be used for explicit type conversions, **`explicit`** is usually preferred because it prevent compilers from performing unexpected (often unintended) type conversions.

#### Copy Constructor vs Copy Assignment Operator <a href="#copy-constructor-vs-copy-assignment-operator" id="copy-constructor-vs-copy-assignment-operator"></a>

The *copy constructor* is used to initialize an object with a different object of the same type, and the *copy assignment operator* is used to copy the value from one object to another of the same type:

```
class Widget
{
public:
  Widget();                                 //  default constructor
  Widget(const Widget& rhs);                //  copy constructor
  Widget& operator=(const Widget& rhs);     //  copy assignment operator
  .....
};

Widget w1;                                  //  invoke default constructor
Widget w2(w1);                              //  invoke copy constructor
w1 = w2;                                    //  invoke copy assignment operator
Widget w3 = w2;                             //  invoke copy constructor
```

Fortunately, copy constructor is easy to distinguish from copy assignment. If a new object is being defined, a constructor has to be called; it can't be assignment. If no new object is being defined, no constructor can be involved, so it's an assignment.

### Standard Template Library (STL)

*STL* is the part of C++'s standard library devoted to [containers](http://en.cppreference.com/w/cpp/container) (e.g., [vector](http://en.cppreference.com/w/cpp/container/vector), [list](http://en.cppreference.com/w/cpp/container/list), [set](http://en.cppreference.com/w/cpp/container/set), [map](http://en.cppreference.com/w/cpp/container/map), etc), [iterators](http://en.cppreference.com/w/cpp/iterator) (e.g., `vector<int>::iterator`, `set<string>::iterator`, etc.), [algorithms](http://en.cppreference.com/w/cpp/algorithm) (e.g. `for_each`, `find`,`sort` etc.), and related functionality.


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://sahibyar.gitbook.io/effective-cpp-summary/readme.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.