Отличие объявления, определения и инициализации

int a = 3;

int val = 1024;
int val (1024);

int a(1024);//инициализация

int a;//создаем со значением по умолчанию (в данном случае с мусором)
a=1024;//не инициализация, а присвоение начального значения.

int a;//инициализация мусором

int a; // Будет равно нулю.
 
int main()
{
    int b; // А вот здесь будет мусор.
 
    return 0;
}

int a; // неинициализированный объект

int F1(int a);
{
    int i,j;
    ...
    j=F2(i);
 
    return ...
}
 
int F2 (int x)
{
 ...
}

int F2(int);  // Декларация F2
 
int F1(int a);
{
    int i,j;
    ...
    j=F2(i);
 
    return ...
}
 
int F2 (int x)  // Дефиниция F2 (определение)
{
 ...
}

int F2 (int x)  // Дефиниция F2 (определение)
{
 ...
}
 
int F1(int a);
{
    int i,j;
    ...
    j=F2(i);
 
    return ...
}

#include <iostream>
#include <string>
#include <typeinfo.h>
using namespace std;
class A {
int a;
double b;
string c;
public:
    A()
        :a(1), b(2.0), c("a anb b were sitting on a pipe")  
    {}
A(int a_)//частично инициализирует
:a(a_)
{}
A(double b_)//частично инициализирует
:b(b_)
{}
A(string c_)//частично инициализирует
:c(c_)
{}
A(const A& orig)//копирующий (и полностью инициализирующий)
:a(orig.a), b(orig.b), c(orig.c)
{}
    int& propertyA(){
return a;
}
    double& propertyB(){
return b;
}
string& propertyC(){
return c;
}
};
int main()
 {
     A *b=new A;//динамическая память выделена но не инициализирована
     cout<<b->propertyA()<<endl;//мусор если конструктор по умолчанию (без параметров) закоментирован
 
     A a;//память на стеке выделена
     cout<<a.propertyA()<<endl;////мусор если конструктор закоментирован
     a.propertyA()=2;// заполняется простым присваиванием
     a.propertyB()=5.0;// заполняется простым присваиванием
     a.propertyC()="a+b= ";// заполняется простым присваиванием
     
     cout<<a.propertyA()<<endl;
     cout<<a.propertyB()<<endl;
     cout<<a.propertyC()<<a.propertyA()+a.propertyB()<<endl;
 
     A c(a);//A c = a; - аналогично, полноценность инициализации определяется полноценность конструктора копии
 
     cout<<c.propertyA()<<endl;
     cout<<c.propertyB()<<endl;
     cout<<c.propertyC()<<a.propertyA()+a.propertyB()<<endl;
 
     A d = "Oi scolco musora budet esli razremite stroki nige...";//работает конструктор преобразования принимающий строку
     //остальные поля не инициализированы
     //отложенную, частичную инициализацию можно использовать для связывания двух экземпляров классов, когда
     //один из них обявлен опережающим объявлением, но не может быть полностью инициализирован без указателя на
     //второй, а второму для создания экземпляра нужен указатель на первый
     //такую штуку (создание пары связянных объектов разных классов можно описать в глобальном или статическом методе
     //или написать для этого отдельный класс.
     cout<<d.propertyC()<<endl;
     //cout<<d.propertyA()<<endl;
     //cout<<d.propertyB()<<endl;
     system("pause");
     }

A(int a_)//частично инициализирует
:a(a_), b(0) // c - не нужно, т.к. std::string инициализируется конструктором по умолчанию
{}