T a;    // Нет никакой инициализации
T a();  // Инициализируем нулями
T a{};  // Инициализируем нулями

class T
{
    T() {}
    T(const T& that) = default;
    T(T&& that) noexcept = default;
    // ...
}

template <typename type_t>
type_t func()
{
    type_t a;   // Тут не происходит инициализации и в случае любого другого POD и в случае T
    type_t b(); // А вот тут в случае POD происходит инициализация нулями, а в случае T её нет ???
}

R>    type_t b(); // А вот тут в случае POD происходит инициализация нулями, а в случае T её нет ???
R>

template <typename type_t>
void func1(const type&);
template <typename type_t>
void func2()
{
    func1(type_t()); // Передаем некий класс и явно вызываем конструктор по умолчанию
}

T a; - Ничего не инициализировал
T a = T(); - Инициализировал

template<class T>T* newPOD() {
    char* data=new char[sizeof(T)];
    if (data) memset(data,0,sizeof(T));
    return (T*)data;
}

template<class T>struct POD {
    char data[sizeof(T)];
    POD() { memset(data,0,sizeof(T)); }
    T* operator ->() { return (T*)data; }
};

...
POD<Point> sp;
moveto(sp->x,sp->y);

Point *dp=newPOD<Point>();
moveto(dp->x,dp->y);
delete dp;

type_t a;    // Если я не хочу "занулять" экземпляр и,
type_t a(0); // Если я хочу "занулить" экземпляр. Что накладывает определенные ограничения на типы, чего хотелось бы избежать.

template <typename T>
class Uninitialized
{
public:

  Unititialized(){}  

  T& operator * () {return reinterpret_cast<T&>(m_storage); }
  const T& operator * () const {return reinterpret_cast<const T&>(m_storage); }
  T* operator -> () {return reinterpret_cast<T*>(m_storage); }
  const T* operator -> () const {return reinterpret_cast<const T*>(m_storage); }

private:
  char m_storage[sizeof(T)];
};

Unitialized<type_t> a;   // Тут не происходит инициализации и в случае любого другого POD и в случае T
type_t b{}; // А вот тут происходит, при нормально написанном конструкторе по умолчанию

template <typename T>
class Uninitialized
{
public:

  Unititialized(){}  

  T& operator * () {return reinterpret_cast<T&>(m_storage); }
  const T& operator * () const {return reinterpret_cast<const T&>(m_storage); }
  T* operator -> () {return reinterpret_cast<T*>(m_storage); }
  const T* operator -> () const {return reinterpret_cast<const T*>(m_storage); }

private:
  alignas(T) char m_storage[sizeof(T)];
};

struct init_t {};
static constexpr init_t init;

struct A
{
  A() {} // нет инициализации
  A(init_t) : x(), y(), z() {}

  int x,y,z;
};

int main()
{
  A unknown_values;
  cout << unknown_values; // UB

  A zero_values(init);
  cout << zero_values.x; // 0
}

#include <iostream>

struct uint128_t
{
    int a;
    double b;
    const int* c;

    uint128_t() = default;

    uint128_t(int, double = {}, const int* = {}); // Какие-то еще другие конструкторы
};

void test(const uint128_t& v)
{
    std::cout << "{ " << v.a << ", " << v.b << ", " << v.c << " }" << std::endl;
}

int main()
{
    uint128_t x; // No initialization
    uint128_t y = uint128_t(); // Zero-initialization
    uint128_t z{}; // Zero-initialization

    test(x);
    test(y);
    test(z);
}