#include <iostream>

int main() {
    const char* str1 = "hello";
    const char* str2 = "hello";

    std::cout << "Address of str1: " << static_cast<const void*>(str1) << std::endl;
    std::cout << "Address of str2: " << static_cast<const void*>(str2) << std::endl;


    return 0;
}

#include <iostream>

class MyClass {
public:
    const int value;
    constexpr MyClass(int v) : value(v) {}
};

int main() {
    const MyClass* obj1 = new MyClass(5);
    const MyClass* obj2 = new MyClass(5);

    std::cout << "Address of obj1: " <<static_cast<const void*>(obj1) << std::endl;
    std::cout << "Address of obj2: " << static_cast<const void*>(obj2) << std::endl;

    return 0;
}

struct house
{
    int number_of_rooms;
};

constexpr house my_house{ 3 };
constexpr house my_sister_house{ 3 };
constexpr house parent_house{ 5 };
constexpr house grand_parent_house{ 4 };

const std::map< std::pair< const house *, const house * >, int > distances={
    {{&my_house, &my_sister_house}, 10},
    {{&my_house, &parent_house}, 12},
    {{&my_house, &my_sister_house}, 20},
    {{&my_house, &grand_parent_house}, 42},

    {{&my_sister_house, &parent_house}, 12},
    {{&my_sister_house, &my_sister_house}, 20},
    {{&my_sister_house, &grand_parent_house}, 42},
};

S>#include <iostream>

S>int main() {
S>    const char* str1 = "hello";
S>    const char* str2 = "hello";

S>    std::cout << "Address of str1: " << static_cast<const void*>(str1) << std::endl;
S>    std::cout << "Address of str2: " << static_cast<const void*>(str2) << std::endl;


S>    return 0;
S>}
S>

#include <iostream>

int main() {
    const char* str1 = "hello";
    const char* str2 = "hello";

    std::cout << "Address of str1: " << &str1 << std::endl;
    std::cout << "Address of str2: " << &str2 << std::endl;
}

9 Evaluating a string-literal results in a string literal object with static storage duration ([basic.stc]).

[Note 4: String literal objects are potentially non-unique ([intro.object]). Whether successive evaluations of a string-literal yield the same or a different object is unspecified.
— end note]

N>Скоро узнаешь о концепции COW, восхитишься, начнёшь применять. Потом поймаешь тормоза в многопоточке, разберёшься и откажешься. И начнёшь использовать всё по месту и по необходимости.

S>....как-то не задумывался что это может иметь такие последствия.

S>Если константный класс (конструктор с const) — то ограничения не касаются тела методов, к сожалению Но просто для себя знайте что такие методы не должны иметь т.н. побочных эффектов. Если допустили побочный эффект — ССЗБ, не нужно было делать const-конструктор.

    constexpr MyClass obj1(5);
    constexpr MyClass obj2(5);

    std::cout << obj1.value << std::endl;
    std::cout << obj2.value << std::endl;

sub     rsp, 8
mov     esi, 5
mov     edi, OFFSET FLAT:std::cout
call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
mov     rdi, rax
call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&) [clone .isra.0]
mov     esi, 5
mov     edi, OFFSET FLAT:std::cout
call    std::basic_ostream<char, std::char_traits<char> >::operator<<(int)
mov     rdi, rax
call    std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&) [clone .isra.0]
xor     eax, eax
add     rsp, 8
ret

#include <iostream>

class MyClass {
public:
 int value;
    constexpr MyClass(int v) : value(v) {}
};

int main() {
    const MyClass* obj1 = new MyClass(5);
    const MyClass* obj2 = new MyClass(5);

    std::cout << "Address of obj1: " <<static_cast<const void*>(obj1) << std::endl;
    std::cout << "Address of obj2: " << static_cast<const void*>(obj2) << std::endl;

    return 0;
}

#include <iostream>

class MyClass {
public:
    const int value;
    constexpr MyClass(int v) : value(v) {}
};

int main() {
    const MyClass* obj1 = new MyClass(5);
    const MyClass* obj2 = new MyClass(5);

    std::cout << "Address of obj1: " <<static_cast<const void*>(obj1) << std::endl;
    std::cout << "Address of obj2: " << static_cast<const void*>(obj2) << std::endl;
    
    delete obj1;
    delete obj2;

    return 0;
}

const start = new Date();

// какие то вычисления...

const end = new Date();

System.out.println("Elapsed: " + (end - start)); // Упс ((

error: illegal start of expression
const start = new Date();

#include <iostream>

template <typename T, auto...x>
inline T Object{x...};

//////////////////////////////////////////////////////////

class MyClass {
public:
    const int value;
    MyClass(int v) : value(v) {}
};

int main() {
    const MyClass& obj1 = Object<MyClass, 5>;
    const MyClass& obj2 = Object<MyClass, 5>;
    const MyClass& obj3 = Object<MyClass, 10>;
    const MyClass& obj4 = Object<MyClass, 10>;

    std::cout << "Address of obj1: " << &obj1 << std::endl;
    std::cout << "Address of obj2: " << &obj2 << std::endl;
    std::cout << "Address of obj3: " << &obj3 << std::endl;
    std::cout << "Address of obj4: " << &obj4 << std::endl;
}

const MyClass* obj1 = new const MyClass(5);

class Konst {};

const Konst* k1 = new const Konst();
const Konst* k2 = new const Konst();

assert(*k1 == *k2);  // эквивалентность значений - это мы и так уже ожидаем
assert(k1 == k2);  // идентичность объектов - то, что хочешь внедрить ты

// а теперь страшное!
delete k1;
delete k2;  // ведь мы сделали два new, - значит, и два delete должны

struct Var {
  int x;
  constexpr Var(int a, int b) : x(a+b) {}
};

Var v(1, 2);
v.x += 4;

constexpr Var foo(int a, int b, int c) {
  Var v(a, b);
  v.x += c;
  return v;
}

int bar[foo(1, 2, 4).x];  // тут хочешь не хочешь, а константа времени компиляции

template<Var v> struct Buz {};

Buz<foo(1, 2, 4)> buz;  // Buz<Var{.x=7}>  // константа времени компиляции

constexpr Var foo1(int a, int b) {
  Var* p = new Var(a, 0);  // p->x = a
  Var* q = new Var(b, 0);  //             q->x = b
  p->x += q->x;            // p->x = a+b                q не трогаем, это отдельный объект
  q->x += p->x;            //             q->x = a+b+b
  Var v = *q;
  delete p; delete q;
  return v;
}

struct Konst { int x; int y; int z; };  // у таких структур, кстати, конструкторы из коробки constexpr

// глобальные константы
const Konst abc1{1, 2, 3};
const Konst abc2{1, 2, 3};  // знаю-знаю, тебе вот этого как раз не хочется
const Konst def {4, 5, 6};

static_assert(&abc1 != &abc2);

// где-то по месту используешь имена вместо выражений
// ..... abc1 ..... abc1 ..... def ..... def .....


// ну ок, допустим, тебе лень где-то держать эти константы, экспортировать их ещё... но хочется синглетонности.
// внимание, трюк!

template<Konst k> struct Storage {
  static constexpr Konst instance = k;
};

// используешь выражения сколько угодно раз
const Konst& xxx = Storage<Konst{1,2,3}>::instance;
const Konst& yyy = Storage<Konst{1,2,3}>::instance;

static_assert(&xxx == &yyy);

return Scaffold(
      appBar: AppBar(
        leading: const IconButton(
          icon: Icon(Icons.menu),
          tooltip: 'Navigation menu',
          onPressed: null,
        ),
        title: const Text('Example title'),
        actions: const [
          IconButton(
            icon: Icon(Icons.search),
            tooltip: 'Search',
            onPressed: null,
          ),
        ],
      ),
      // body is the majority of the screen.
      body: const Center(
        child: Text('Hello, world!'),
      ),
      floatingActionButton: const FloatingActionButton(
        tooltip: 'Add', // used by assistive technologies
        onPressed: null,
        child: Icon(Icons.add),
      ),
    );

const char* obj1 = "text";
const MyClass* obj2 = new MyClass(5);