DEV Community: Aastha Gupta

Quick Introduction to class in C++

Aastha Gupta — Wed, 07 Jul 2021 13:32:59 +0000

A class is a data type that you define and you can also add some functions that work on this data type. That's it, that is exactly what a class is! Thank you for reading this article and I'll see you in the next one.

wait . . .

Above explanation is simple and covers what a class is in as little words as possible but there are more caveats related to it and I'll go over them in this article.

Declaring a class

class Cat {
   private:

      // data memebers
      string breed;
      int legs;

   public:
      // constructor
      Cat () {  
        breed = "Sphynx";
        legs = 4;
        meow = true;
      }

      // member function
      void setLegs(int num) {
         legs = num;
      }

      // member function
      void setBreed(string breed_name) {
         breed = breed_name;
      }
};

Data members

What you create of classes are objects. These objects have certain properties that can be accessed and these can be defined in the class as data members. For a Table it can be wood type, number of drawers, length, height etc. By creating an object of a table, you can assign values to these properties in accordance with their data types.

A class is a plan, object it's execution

Member functions

You might want your objects to perform some tasks and for that you write member functions. These functions are like regular functions accept they are only accessible to the object of the class; which means the functions can or can not take parameters, it can or cannot or return something back. Member functions are a powerful and you must use them with caution.

Inheritance in C++ can be achieved by deriving a class from another class of which access specifiers are an important part. I'll pick these topics up in my future articles. Stay tuned! If you want to read more about classes, head over here

Thanks for giving this article a read and I'll see you in the next one 😄

PS: This is an article in my series Quick Introduction to a concept in C++. You can find all the articles in this series here. I also answer why I don't use the series feature by dev.to there.

Quick Introduction to header files in C++

Aastha Gupta — Mon, 28 Jun 2021 16:19:09 +0000

Using a variable (or function or a class and so on) without declaring it, is an error in C++; more specifically, this error:

In function 'int main()':
error: 'x' was not declared in this scope
  x = 2;
  ^
[ERROR in Compilation]

which means, it is important to declare an element before using it or assigning it a value, in C++.

(The word element refers to functions, classes, structs, variables etc throughout this article.)

We might end up declaring and defining various elements repeatedly in our different C++ programs if they're useful in varied cases. This would result in a lot of code repetition throughout our code-base; and making one change in an element would result in copying the same change over and over again in different files.

sounds scary !

Therefore, it makes sense to declare and define commonly used elements that are predicted to be of use often before hand and use them later without worrying about their declaration. To keep our code modular, it fits to combine such 'utility' elements in one single file and keep importing it in other c++ programs.

Enter header files; these are declarations and definitions of various elements which are ready to be used in a c++ program. Header files have a .h extension instead of a .cpp one; this tells everyone that my_file.h is a header file that contains declarations and definitions of various 'utility' elements. A header file can than be included in a cpp program as such :

Want to write good a header file? Keep the following points in mind while writing one :

Do not bring complete namespaces into scope with the using directive (read more about using here) as this might conflict with other elements present in the file where this header is being included into.
Use const variable definitions to make sure a program including this header file cannot change it.
Use inline function definitions and named namespaces.

Standard library header files enable various useful functionalities in our C++ programs. Moreover, we can write our own header files to make our code-base modular and thus, more understandable.

This article was a short introduction and if you want to know more about various header files in C++, I encourage you to head over here.

Thanks for giving this article a read and I'll see you in the next one 😄

PS: This is an article in my series Quick Introduction to a concept in C++. You can find all the articles in this series here.

Quick Introduction to a concept in C++

Aastha Gupta — Thu, 17 Jun 2021 15:48:06 +0000

I've been writing C++ programs since past 5 years now (I didn't realize it has been that long until I typed this out) and have come across various concepts that beginners seem to struggle with.

To help my fellow programmers in the community, I started a series of articles called Quick Introduction to a concept in C++. These articles are generally 2 to 5 minute reads that cover a specific concept in C++ in simple words, contain examples and point to comprehensive resources as well.

I read and reply to comments often, and you can suggest any topics you'd like to be covered in this series.

Here is a list of all the articles currently in the series :
(I'll keep updating this list as and when I write new articles)

Quick Introduction to namespaces in C++
Quick Introduction to using in C++
Quick Introduction to typedef in C++
Quick Introduction to header files in C++
Quick Introduction to class in C++

Why don't you use the series feature provide by dev.to?
Simply because it breaks the flow of the article. Different articles in the series are crowded on the top of the current article, which diverts the attention of the reader. I personally do not like that and therefore take the pain to update this post every time I write a new article in the series Quick Introduction to a concept in C++ :)

Consider reacting to the articles with a like, unicorn or a comment and sharing it with your friends if you like them and appreciate my efforts put into writing them. This helps the article reach more people who might benefit from these; no pressure though, I appreciate you just reading my article irrespective of you sharing or reacting to it.

As always, thanks for giving this article a read and I'll see you in the next one 😄

Quick Introduction to namespaces in C++

Aastha Gupta — Thu, 17 Jun 2021 15:43:43 +0000

As someone who writes C++ code often, I see (and use) the keyword namespace frequently and I think it is worth knowing what this keyword is all about.

A namespace is a region that provides a scope to the identifiers (the names of functions, variables, etc) inside it. namespaces are used to organize code into logical groups. All identifiers in the namespace scope are visible to one another.

The identifiers in the namespace can be accessed by bringing those said identifiers into the current scope by using or utilizing fully qualified names.

using namespace std;
// the namespace std is now in scope
string my_string;

std::string my_string
// fully qualified name

Declaring `namespace` and `namespace members`

A namespace declaration is generally done in a header file as following:

// my_namespace_declaration.h

namespace my_own_namepsace
{
    void func_one();
    int func_two();
}

The members of this namespace can then be brought into scope of any other file by fully qualified names or the using directive. (If you want to know more about using, checkout this article by me)

// other_file.cpp

#include"my_own_namepsace.h"
using namespace my_own_namepsace;

my_own_namepsace::func_one();
// fully qualified names are to be used
// even when bringing the namespace in 
// scope with using directive

Code in a header file that uses identifiers from other namespaces should always use the fully qualified namespace name to avoid ambiguity. This isocpp core guideline puts more light.

Nested namespaces

namespaces can be nested. A nested namespace has unqualified access to its parent's members however the parent members do not have unqualified access to the nested namespace (unless it is declared as inline).

The std namespace

All C++ standard library types and functions are declared in the std namespace or the various namespaces that are nested inside std which makes it one of the most common namespaces to be encountered.

This article is a short introduction and if you want to know more about namespaces, I encourage you to head over here.

Thanks for giving this article a read and I'll see you in the next one 😄

PS: This is an article in my series Quick Introduction to a concept in C++. You can find all the articles in this series here.

typedef VS using in type aliases declaration in C++

Aastha Gupta — Mon, 14 Jun 2021 07:47:24 +0000

In my previous posts, typedef and using were introduced. If you haven't read them, I'd recommend to check them out first before proceeding with this one ( typedef and using ).

Let's look at the following code snippets:

using flags = std::ios_base::fmtflags;

typedef std::ios_base::fmtflags flags;

Both these code snippets are equivalent! Infact, In C++11, the using keyword when used for type alias is identical to typedef.

using is used specifically to type-alias template instead of typedef and this paper explains it very well so.

An excerpt from the paper:

It has been suggested to (re)use the keyword typedef — as done in the paper [4] — to introduce template aliases:

template<class T> 
   typedef std::vector<T, MyAllocator<T> > Vec;

That notation has the advantage of using a keyword already known to introduce a type alias. However, it also displays several disadvantages among which the confusion of using a keyword known to introduce an alias for a type-name in a context where the alias does not designate a type, but a template; Vec is not an alias for a type, and should not be taken for a typedef-name. The name Vec is a name for the family std::vector< [bullet] , MyAllocator< [bullet] > > – where the bullet is a placeholder for a type-name. Consequently we do not propose the typedef syntax. On the other hand the sentence


    template<class T>
        using Vec = std::vector<T, MyAllocator<T> >;

can be read/interpreted as: from now on, I’ll be using Vec<T> as a synonym for std::vector<T, MyAllocator<T> >. With that reading, the new syntax for aliasing seems reasonably logical.

You might wonder why a new keyword was not introduced and why using was reused; there is infact a pretty good reason behind the rationale of not introducing a new keyword or new syntax every so often. The standard wants to avoid breaking old code as much as possible. This is why in proposal documents you might encounter sections like Impact on the Standard, Design decisions, and how they might affect older code. There are situations when a proposal seems like a really good idea but might not have traction because it would be too difficult to implement or too confusing, or would contradict old code which is something that should be avoided.

Thanks for giving this article a read and I'll see you in the next one 😄

Quick Introduction to using in C++

Aastha Gupta — Mon, 14 Jun 2021 02:47:47 +0000

If you've ever written a c++ code snippet, I predict that you've seen this particular line :

using namespace std;

and thought to yourself, 'what does using mean?'

using is a keyword in C++ which is applicable in the following cases:

Bring all members from the namespace into the current scope.

The using directive allows all the names in a namespace to be used without the namespace-name as an explicit qualifier.

using namespace std; 
// brings all namespace names in the current scope
string my_string;
// std::string can now be referred as string throughout the scope

OR

std::string my_string; 
// string is now recognized, 
// however, will have to be addressed as std::string 
// wherever required

So now you know what using does in :

using namespace std

It brings namespace std in scope which makes it handy to use names in std without the explicit prefix std::

If a local variable has the same name as a namespace variable, the namespace variable is hidden. It is, therefore, a good practice to not bring complete namespaces in scope in long code files to avoid such cases where an intuitive identifier name has to be dropped 🙁 because same name exists in the namespace brought in scope by using. A workaround is to bring a specific name from a namespace in scope as:

using std::string;

Bring a base class method or variable into the current class’ scope.

class BaseClass {
   public:
      void sayHi() {
         cout << "Hi there, I am Base" << endl;;
      }
};

class DerivedClass : BaseClass {
   public:
      using Base::sayHi; 
      void sayHi(string s) {
         cout << "Hi, " << s << endl;
         // Instead of recursing, the greet() method
         // of the base class is called.
         sayHi();
      }
};

Create type aliases

template <typename T>
using MyName = MyVector<T, MyAlloc<T> >; 
MyName<int> p; // sample usage

using flags = std::ios_base::fmtflags;
// identical to 
// typedef std::ios_base::fmtflags flags;

typedef already exists in the C++ language which makes one wonder, why using was introduced to create type aliases. This is a valid question and an interesting one. There are a few interesting facts associated with typedef and using type aliases which you can read in this post 😄.

There are more caveats to using but are not covered here because this is a quick introduction, and also because of how rarely they are encountered. I encourage you to read more about using here.

Thanks for giving this article a read and I'll see you in the next one 😄

PS: This is an article in my series Quick Introduction to a concept in C++. You can find all the articles in this series here. I also answer why I don't use the series feature by dev.to there.

Quick Introduction to typedef in C++

Aastha Gupta — Sat, 08 May 2021 06:45:25 +0000

C++ is a strongly typed language which means we take types very seriously in the C++ community! While types are important and reduce bugs, it gets tiresome pretty quickly when there's an inbuilt type with a long name that you’ve to use repetitively throughout your code.

// Examples

unsigned long num;

std::pair <std::string,double> product_one;

Introducing typedef declarations, easy effortless way to declare and use types in your file. typedef declarations can be considered as nicknames✨ that you give to an inbuilt type and whenever you want to say inbuilt-type, you say their nickname instead.

typedef unsigned long UL; 
UL num; // Equivalent to unsigned long num;

typedef std::pair <std::string,double> PRODUCT
PRODUCT product_one("notebook",54.5); 
// Equivalent to std::pair <std::string,double> ("notebook",54.5);

In contrast to the class, struct, union, and enum declarations, typedef declarations do not introduce new types, they simply introduce new names for existing types. What’s more exciting is that you can declare any type with typedef, including pointers, functions and array types.

typedef struct {int a; int b;} STRUCT, *p_STRUCT;

// the following two objects have the same type
pSTRUCT p_struct_1;
STRUCT* p_struct_2;

typedef declarations are scoped, that is you can declare a variable with the same name as of the typedef in the same file in a different scope and you’ll face no type errors whatsoever!

typedef unsigned long UL;   
int main()
{
   unsigned int UL;   
   // re-declaration hides typedef name
   // now UL is an unsigned int variable in this scope
}

// typedef UL back in scope

However, I would highly advise against this practice because it eventually makes your file less readable and more confusing which is not something you’d want to do.🤷

In summary, you can use typedef declarations to construct shorter and more meaningful names to the types that are already defined by the language or for the types that you have declared.

Hopefully this article gave you a brief introduction to typedef and you had fun reading it. To get more information on the topic, refer the docs here.

Thanks for giving this article a read and I'll see you in the next one 😄

DEV Community: Aastha Gupta

Quick Introduction to class in C++

Declaring a class

Data members

Member functions

Quick Introduction to header files in C++

Quick Introduction to *a concept* in C++

Quick Introduction to namespaces in C++

Declaring namespace and namespace members

Nested namespaces

The std namespace

typedef VS using in type aliases declaration in C++

Quick Introduction to using in C++

Bring all members from the namespace into​ the current scope.

Bring a base class method ​or variable into the current class’ scope.

Create type aliases

Quick Introduction to typedef in C++

Quick Introduction to a concept in C++

Declaring `namespace` and `namespace members`

Bring all members from the namespace into the current scope.

Bring a base class method or variable into the current class’ scope.