#include <array>
#include <string>
#include <optional>
#include <iostream>
#include <memory>

namespace com
{
    template<typename interface_t>
    class ptr
    {
    public:
        ptr(interface_t* ptr = nullptr) noexcept { m_ptr = ptr; }

        operator interface_t*() const noexcept { return m_ptr; }

    private:
        interface_t* m_ptr;
    };
}

class pin
{
public:
    pin(int* v) {};
};


int main()
{
    std::array<com::ptr<int>, 10> arr_of_ptr;

    for (pin p : arr_of_ptr) // error:  no viable conversion from 'value_type'
    { 

    }
    
    pin p1(arr_of_ptr[0]);  // ок:      case 1
    pin p2 = arr_of_ptr[0]; // error:   case 2

}

pin p2 = (int*)arr_of_ptr[0]; // error:   case 2

struct A
{
   int a;
   std::string b;
   float c;
   //итд

//  A(int aa):a(aa){} // не обявив явно не работает в gcc clang
};

int main()
{
    auto p = std::make_shared<A>(3);
}

R>struct A
R>{
R>   int a;
R>   std::string b;
R>   float c;
R>   //итд

R>//  A(int aa):a(aa){} // не обявив явно не работает в gcc clang
R>};

R>int main()
R>{
R>    auto p = std::make_shared<A>(3);
R>}
R>

void foo(A);

int main()
{
    foo(3);
}

A a_explicit{42}; // OK

A a_implicit = 42; // error: conversion from 'int' to non-scalar type 'A' requested

virtual ~A(){}

struct AA
{
   unsigned short a;
   unsigned int b;
};

int main()
{
    std::vector<AA> aa;
    std::list<AA> cc;
    
    aa.emplace_back(1,2);
    cc.emplace_back(1,2);
}

#include<string>
#include<map>
#include<vector>
struct AA
{
   std::string a;
   unsigned int b;
   std::string c;
   unsigned char d;
   std::vector<unsigned int> e;
   bool f;
   bool h;
};

int main()
{
    std::map<unsigned short, AA> aa;
    aa.insert(std::make_pair(1,"d"));
}