Inheritance diagram for xtd::object:

Definition

Supports all classes in the xtd class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all classes in the xtd. It is the root of the type hierarchy.

class core_export_ object

xtd::object::object

object()=default

Create a new instance of the ultimate base class object.

core_export_

#define core_export_

Define shared library export.

Definition core_export.hpp:13

Namespace: xtd

Library: xtd.core

Examples: The following example defines a point type derived from the xtd::object class and overrides many of the virtual methods of the xtd::object class. In addition, the example shows how to call many of the static and instance methods of the xtd::object class.
#include <xtd/xtd>

// The Point class is derived from System.Object.

class point : public object {

public:

int x, y;

point(int x, int y) : x {x}, y {y} {}

bool equals(const object& obj) const noexcept override {

// If this and obj do not refer to the same type, then they are not equal.

if (obj.get_type() != get_type()) return false;

// Return true if x and y fields match.

auto& other = static_cast<const point&>(obj);

return x == other.x && y == other.y;

}

// Return the XOR of the x and y fields.

size_t get_hash_code() const noexcept override {

return x ^ y;

}

// Return the point's value as a string.

string to_string() const noexcept override {

return string::format("({}, {})", x, y);

}

// Return a copy of this point object by making a simple field copy.

uptr<point> copy() const {

return memberwise_clone<point>();

}

};

auto main() -> int {

// Construct a Point object.

auto p1 = point {1, 2};

// Make another Point object that is a copy of the first.

auto p2 = p1.copy();

// Make another variable that references the first point object.

auto& p3 = p1;

// The line below displays false because p1 and p2 refer to two different objects.

console::write_line(object::reference_equals(p1, *p2));

// The line below displays true because p1 and p2 refer to two different objects that have the same value.

console::write_line(object::equals(p1, *p2));

// The line below displays true because p1 and p3 refer to one object.

console::write_line(object::reference_equals(p1, p3));

// The line below displays: p1's value is: (1, 2)

console::write_line("p1's value is: {}", p1.to_string());

}

// This code produces the following output :

//

// false

// true

// true

// p1's value is: (1, 2)

xtd::object::equals
virtual bool equals(const object &obj) const noexcept
Determines whether the specified object is equal to the current object.

xtd::object::get_hash_code
virtual xtd::size get_hash_code() const noexcept
Serves as a hash function for a particular type.

xtd::object::memberwise_clone
xtd::unique_ptr_object< object_t > memberwise_clone() const
Creates a shallow copy of the current object.

xtd::object::to_string
virtual xtd::string to_string() const
Returns a xtd::string that represents the current object.

xtd::basic_string< char >::format
static basic_string format(const basic_string< char > &fmt, args_t &&... args)

xtd::platform_id::other
@ other
The operating system is other.
Definition platform_id.hpp:60

xtd::console_key::y
@ y
The Y key.
Definition console_key.hpp:136

xtd::console_key::x
@ x
The X key.
Definition console_key.hpp:134

xtd::drawing::graphics_unit::point
@ point
Specifies a printer's point (1/72 inch) as the unit of measure.
Definition graphics_unit.hpp:25

Examples: ball.cpp, event.cpp, iformatable.cpp, and iformatable_vs_to_string.cpp.

Public Constructors
	object ()=default
	Create a new instance of the ultimate base class object.

Public Methods
virtual bool	equals (const object &obj) const noexcept
	Determines whether the specified object is equal to the current object.
virtual xtd::size	get_hash_code () const noexcept
	Serves as a hash function for a particular type.
virtual type_object	get_type () const noexcept
	Gets the type of the current instance.
template<class object_t>
xtd::unique_ptr_object< object_t >	memberwise_clone () const
	Creates a shallow copy of the current object.
virtual xtd::string	to_string () const
	Returns a xtd::string that represents the current object.

Public Static Methods
template<class object_a_t, class object_b_t>
static bool	equals (const object_a_t &object_a, const object_b_t &object_b) noexcept
	Determines whether the specified object instances are considered equal.
template<class object_a_t, class object_b_t>
static bool	reference_equals (const object_a_t &object_a, const object_b_t &object_b) noexcept
	Determines whether the specified object instances are the same instance.

Constructor & Destructor Documentation

◆ object()

xtd::object::object ( )

default

Create a new instance of the ultimate base class object.

Remarks: This constructor is called by constructors in derived classes, but it can also be used to directly create an instance of the object class.

Member Function Documentation

◆ equals() [1/2]

virtual bool xtd::object::equals ( const object & obj ) const

virtualnoexcept

Determines whether the specified object is equal to the current object.

Parameters

obj	The object to compare with the current object.

Returns: true if the specified object is equal to the current object. otherwise, false.

Examples: The following code example compares the current instance with another object.
#include <xtd/xtd>

auto main() -> int {

auto object1 = new_ptr<object>();

auto object2 = new_ptr<object>();

auto object3 = object2;

console::write_line(object1->equals(*object3));

console::write_line(*object1 == *object3);

object3 = object1;

console::write_line(object1->equals(*object3));

console::write_line(*object1 == *object3);

}

// This code produces the following output :

//

// false

// false

// true

// true

xtd::console::write_line
static void write_line()
Writes the current line terminator to the standard output stream using the specified format informati...

xtd::new_ptr
ptr< type_t > new_ptr(args_t &&... args)
The xtd::new_ptr operator creates a xtd::ptr object.
Definition new_ptr.hpp:24

Examples: generic_icollection.cpp, and generic_ilist.cpp.

◆ get_hash_code()

virtual xtd::size xtd::object::get_hash_code ( ) const

virtualnoexcept

Serves as a hash function for a particular type.

Returns: A hash code for the current object.

◆ get_type()

virtual type_object xtd::object::get_type ( ) const

virtualnoexcept

Gets the type of the current instance.

Returns: The type instance that represents the exact runtime type of the current instance.

Examples: The following code example demonstrates that xtd::object::get_type returns the runtime type of the current instance.
#include <xtd/xtd>

class my_base_class : public object {

};

class my_derived_class: public my_base_class {

};

auto main() -> int {

auto my_base = my_base_class {};

auto my_derived = my_derived_class {};

object& o = as<object>(my_derived);

my_base_class& b = as<my_base_class>(my_derived);

console::write_line("my_base: type is {}", my_base.get_type());

console::write_line("my_derived: type is {}", my_derived.get_type());

console::write_line("object o = my_derived: type is {}", o.get_type());

console::write_line("my_base_class b = my_derived: type is {}", b.get_type());

console::write_line();

console::write_line("my_base: type is {}", typeof_(my_base));

console::write_line("my_derived: type is {}", typeof_(my_derived));

console::write_line("object o = my_derived: type is {}", typeof_(o));

console::write_line("my_base_class b = my_derived: type is {}", typeof_(b));

}

// This code produces the following output :

//

// my_base: type is my_base_class

// my_derived: type is my_derived_class

// object o = my_derived: type is my_derived_class

// my_base_class b = my_derived: type is my_derived_class

//

// my_base: type is my_base_class

// my_derived: type is my_derived_class

// object o = my_derived: type is my_derived_class

// my_base_class b = my_derived: type is my_derived_class

typeof_
#define typeof_
Used to obtain the type object of a specified type or object.
Definition typeof.hpp:45

xtd::console_key::b
@ b
The B key.
Definition console_key.hpp:90

xtd::console_key::o
@ o
The O key.
Definition console_key.hpp:116

◆ memberwise_clone()

template<class object_t>

xtd::unique_ptr_object< object_t > xtd::object::memberwise_clone ( ) const

Creates a shallow copy of the current object.

Returns: A shallow copy of the current object.

Examples: The following example illustrates the xtd::object::memberwise_clone method. It defines a shallow_copy method that calls the xtd::object::memberwise_clone method to perform a shallow copy operation on a person object. It also defines a deep_copy method that performs a deep copy operation on a person object.
#include <xtd/xtd>

class id_info : public object {

public:

int id_number = 0;

explicit id_info(int id_number) : id_number {id_number} {}

};

class person : public object {

public:

int age = 0;

ptr<string> name = new_ptr<string>();

ptr<::id_info> id_info = new_ptr<::id_info>(0);

uptr<person> shallow_copy() {

return memberwise_clone<person>();

}

uptr<person> deep_copy() {

auto other = memberwise_clone<person>();

other->id_info = new_ptr<::id_info>(this->id_info->id_number);

other->name = new_ptr<string>(*name);

return other;

}

};

void display_values(const person p) {

console::write_line(" name: {0:s}, age: {1:d}", *p.name, p.age);

console::write_line(" value: {0:d}", p.id_info->id_number);

}

auto main() -> int {

// Create an instance of person and assign values to its fields.

auto p1 = new_uptr<person>();

p1->age = 42;

*p1->name = "Sam";

*p1->id_info = id_info {6565};

// Perform a shallow copy of p1 and assign it to p2.

auto p2 = p1->shallow_copy();

// Display values of p1, p2

console::write_line("Original values of p1 and p2:");

console::write_line(" p1 instance values: ");

display_values(*p1);

console::write_line(" p2 instance values:");

display_values(*p2);

// Change the value of p1 properties and display the values of p1 and p2.

p1->age = 32;

*p1->name = "Frank";

p1->id_info->id_number = 7878;

console::write_line("\nValues of p1 and p2 after changes to p1:");

console::write_line(" p1 instance values: ");

display_values(*p1);

console::write_line(" p2 instance values:");

display_values(*p2);

// Make a deep copy of p1 and assign it to p3.

auto p3 = p1->deep_copy();

// Change the members of the p1 class to new values to show the deep copy.

*p1->name = "George";

p1->age = 39;

p1->id_info->id_number = 8641;

console::write_line("\nValues of p1 and p3 after changes to p1:");

console::write_line(" p1 instance values: ");

display_values(*p1);

console::write_line(" p3 instance values:");

display_values(*p3);

}

// This code produces the following output :

//

// Original values of p1 and p2:

// p1 instance values:

// name: Sam, age: 42

// value: 6565

// p2 instance values:

// name: Sam, age: 42

// value: 6565

//

// Values of p1 and p2 after changes to p1:

// p1 instance values:

// name: Frank, age: 32

// value: 7878

// p2 instance values:

// name: Frank, age: 42

// value: 7878

//

// Values of p1 and p3 after changes to p1:

// p1 instance values:

// name: George, age: 39

// value: 8641

// p3 instance values:

// name: Frank, age: 32

// value: 7878

xtd::console_key::p
@ p
The P key.
Definition console_key.hpp:118

In this example, the person::id_info property returns an id_info object. As the output from the example shows, when a person object is cloned by calling the xtd::object::memberwise_clone method, the cloned person object is an independent copy of the original object, except that they share the same person::id_info object reference. As a result, modifying the clone's person::id_info property changes the original object's person::id_info property. On the other hand, when a deep copy operation is performed, the cloned person object, including its person::id_info property, can be modified without affecting the original object.

Remarks

The xtd::object::memberwise_clone method creates a shallow copy by creating a new object, and then copying the nonstatic fields of the current object to the new object. If a field is a value type, a bit-by-bit copy of the field is performed. If a field is a reference type, the reference is copied but the referred object is not; therefore, the original object and its clone refer to the same object.

For example, consider an object called X that references objects A and B. Object B, in turn, references object C. A shallow copy of X creates new object X2 that also references objects A and B. In contrast, a deep copy of X creates a new object X2 that references the new objects A2 and B2, which are copies of A and B. B2, in turn, references the new object C2, which is a copy of C. The example illustrates the difference between a shallow and a deep copy operation.

There are numerous ways to implement a deep copy operation if the shallow copy operation performed by the xtd::object::memberwise_clone method does not meet your needs. These include the following:

Call a class constructor of the object to be copied to create a second object with property values taken from the first object. This assumes that the values of an object are entirely defined by its class constructor.
Call the xtd::object::memberwise_clone method to create a shallow copy of an object, and then assign new objects whose values are the same as the original object to any properties or fields whose values are reference types. The deep_copy method in the example illustrates this approach.
Serialize the object to be deep copied, and then restore the serialized data to a different object variable.
Use reflection with recursion to perform the deep copy operation.

◆ to_string()

virtual xtd::string xtd::object::to_string ( ) const

virtual

Returns a xtd::string that represents the current object.

Returns: A string that represents the current object.

Examples: The following code example demonstrates what to_string returns.
#include <xtd/xtd>

namespace examples {

namespace object_test {

class object1 : public object {

};

}

}

auto main() -> int {

ptr<object> obj1 = new_ptr<examples::object_test::object1>();

console::write_line(obj1->to_string());

ptr<object> obj2 = new_ptr<date_time>(1971, 1, 5, 23, 5, 0);

console::write_line(obj2->to_string());

ptr<object> obj3 = new_ptr<boolean_object>();

console::write_line(obj3->to_string());

}

// This code produces the following output :

//

// examples::object_test::object1

// Tue Jan 5 23:05:00 1971

// false

Examples: iformatable.cpp.

◆ equals() [2/2]

template<class object_a_t, class object_b_t>

bool xtd::object::equals	(	const object_a_t &	object_a,
		const object_b_t &	object_b )

inlinestaticnoexcept

Determines whether the specified object instances are considered equal.

Parameters

object_a	The first object to compare.
object_b	The second object to compare.

Returns: true if object_a is the same instance as object_b or if both are null references or if object_a(object_b) returns true. otherwise, false.

Examples: The following code example compares different objects.
#include <xtd/xtd>

auto main() -> int {

string s1 = "Tom";

string s2 = "Carol";

console::write_line("object::equals(\"{0}\", \"{1}\") => {2}", s1, s2, object::equals(s1, s2));

s1 = "Tom";

s2 = "Tom";

console::write_line("object::equals(\"{0}\", \"{1}\") => {2}", s1, s2, object::equals(s1, s2));

s1 = "";

s2 = "Tom";

console::write_line("object::equals(\"{0}\", \"{1}\") => {2}", s1, s2, object::equals(s1, s2));

s1 = "Carol";

s2 = "";

console::write_line("object::equals(\"{0}\", \"{1}\") => {2}", s1, s2, object::equals(s1, s2));

s1 = "";

s2 = "";

console::write_line("object::equals(\"{0}\", \"{1}\") => {2}", s1, s2, object::equals(s1, s2));

}

// This code produces the following output :

//

// object::equals("Tom", "Carol") => false

// object::equals("Tom", "Tom") => true

// object::equals("", "Tom") => false

// object::equals("Carol", "") => false

// object::equals("", "") => true

◆ reference_equals()

template<class object_a_t, class object_b_t>

bool xtd::object::reference_equals	(	const object_a_t &	object_a,
		const object_b_t &	object_b )

inlinestaticnoexcept

Determines whether the specified object instances are the same instance.

Parameters

object_a	The first object to compare.
object_b	The second object to compare.

Returns: true if object_a is the same instance as object_b or if both are null references; otherwise, false.

Examples: The following code example uses xtd::object::reference_equals to determine if two objects are the same instance.
#include <xtd/xtd>

auto main() -> int {

object* o = nullptr;

object* p = null;

object* q = new object;

console::write_line(object::reference_equals(*o, *p));

p = q;

console::write_line(object::reference_equals(*p, *q));

console::write_line(object::reference_equals(*o, *p));

delete q;

}

// This code produces the following output :

//

// true

// true

// false

xtd::object::reference_equals
static bool reference_equals(const object_a_t &object_a, const object_b_t &object_b) noexcept
Determines whether the specified object instances are the same instance.
Definition object.hpp:137

xtd::null
null_ptr null
Represents a null pointer value.

xtd::console_key::q
@ q
The Q key.
Definition console_key.hpp:120

The documentation for this class was generated from the following file:

xtd.core/include/xtd/object.hpp

Definition

Public Constructors

Public Methods

Public Static Methods

Constructor & Destructor Documentation

◆ object()

Member Function Documentation

◆ equals() [1/2]

◆ get_hash_code()

◆ get_type()

◆ memberwise_clone()

◆ to_string()

◆ equals() [2/2]

◆ reference_equals()