Constructors and Destructors in Carbon

Cases not Supported by Constructors

There are two cases where constructors in Carbon fail to provide adequate support:

• Users cannot create an abstract class value, which is required when the class has private fields or requires initialisation.
   
• Users may wish to decrease the possibility of errors when invoking a method on a partially built object. Calling a virtual method before constructing the derived class is of particular significance. Thus the base class implementation is used.
   

While both of these problems are unlikely to arise, we will solve them with a specific type that is only utilised during building base classes, known as the partial facet type for the class.

Partial Facet

A partial Facet is created to overcome the cases that fail to be solved using Constructors in Carbon. The partial facet of a base class type, such as BaseClass, is denoted by partial BaseClass.

The syntax to use Partial Facet is as follows:

base class BaseClass {
  fn Create() -> partial SelfClass {
    return {.baseClass_field_1 = ..., .baseClass_field_2 = ...};
  }
}

Destructors in Carbon

A Destructor is a type of member function which is invoked immediately when an object is destroyed. When the lifetime of a value of a type expires, or we can say the scope of the variable is completed, a declared destructor function is called. 

The destructor of the class is declared using the destructor keyword.

class CNClass {
  destructor [me: Self] { ... }
}

// OR

class CNClass {
  // Can modify `me` in the body.
  destructor [addr me: Self*] { ... }
}

If a class does not include a destructor declaration, the default destructor is used.

Example:

package ExplorerTest api;
class Sum {

destructor [me: Self] {
    Print ("Calling destructor");
}

var a: i32;

fn Add [me: Self](var num: i32) -> i32
    {
        var total: i32 = me.a + num;
        return total;
    }
}

fn Main() -> i32
{
    var p1: Sum = {.a = 5};
    var total: i32 = p1.Add(5);
    Print("Total sum {0}", total);
	return 0;
}

Output:

Explanation:

The above program implements the destructor inside the class Sum. When we request the Add operation in the main class, the Add method is called. The Add method will add the number to itself and produce the result. In operation, the destructor is called by requesting "me.a".  

Order of Destruction of Members

A class's destructor is executed before the destructors of its data members. The data members are destroyed in the order in which they were declared. Because derived classes are destroyed before their base classes, the following is the order of operations:

• When the derived class's destructor is called, the data members of the derived class are destroyed in the reverse order of declaration.
   
• The destructor of the immediate base class is called, and the data members of the immediate base class are destroyed in reverse order of declaration, and so on.

Virtual and Impl Destructor

We cannot delete an instance of a derived class using a pointer of its base classes. For deleting the instance, we use a virtual destructor. A virtual destructor is a function that deletes a derived class object using a pointer of one of its base classes.

We can declare the destructor of the base class using the virtual keyword. While the destructor for the derived class is declared using the impl keyword.

base class MyBaseClass {
  virtual destructor [addr me: Self*] { ... }
}

class MyDerivedClass extends MyBaseClass {
  impl destructor [addr me: Self*] { ... }
}

Frequently Asked Questions

Is Carbon-lang released?

Carbon, commonly known as Carbon-lang, was introduced as an experimental open-source successor to C++ in July 2022.

Is Carbon language ready to use?

Carbon is still an experimental language, which means some things may change with time. The official doc of Carbon states that “Carbon is not ready for use”. However, some design principles are less likely to change. 

Will Carbon replace C++?

Google's open-source Carbon programming language is not a direct substitute for C++. Instead, it is intended to be a replacement. While it may sound similar, the key difference is that it is intended to be used alongside C++.

What is the purpose of the Carbon language?

Carbon is a general-purpose programming language that is still under development. As of now, it is intended to be a successor to C++. It will be used along with C++ in game development and GUI.

Is garbage collected in Carbon language?

Carbon is intended to be C++-compatible and to communicate with C++ programming readily. As a result, Carbon does not use garbage collection and instead employs destructors.

Conclusion

This article briefly discussed constructors and destructors in Carbon. We discussed what are constructors in Carbon, along with some cases not supported by the constructor and partial facet. Afterwards, we discussed destructors in Carbon, the order of destructor members, and virtual and Impl destructors. Thus concluding our discussion on constructors and destructors in Carbon.

• Carbon Footprint
• Find power recursively in Carbon
• Variables in Carbon

Refer to our Guided Path on Coding Ninjas Studio to upskill yourself in Data Structures and Algorithms, Competitive Programming, JavaScript, AWS and many more! If you wish to test your competency in coding, check out the mock test series and participate in the contests hosted on Coding Ninjas Studio! 

If you have just started your learning process and are looking for questions from tech giants like Amazon, Microsoft, Uber, etc. For placement preparations, you must look at the problems, interview experiences, and interview bundles.

Nevertheless, consider our paid courses to give your career an edge over others!

Happy Learning!