Как определить задан ли элемент массива с указанным индексом.
Допустим у нас есть массив int m[3]={1,2}; Очевидно, что элемент с индексом 2 мы не инициализировали. Как реализовать функцию проверяющую инициализирован ли элемент с индексом index?

А существует ли способ отделить "инициализированный" элемент от "неинициализированного" ? Потому что с точки зрения компьютера, любое число, содержащееся в ячейке с индексом 2, является правильным.

Это можно сделать только на уровне соглашений в проекте. То есть вы выбираете некоторую константу, допустим 0, и считаете, что элемент маасива, имеющий это значение, является неинициализированным.
Тогда в этом случае если рассмотреть два массива

int a[4] = { 1, 2 };
int b[4] = { 1, 2, 0 };

то они будут эквивалентными с точки зрения инициализации своих элементов, так как 3-ий и 4-ый элементы обоих массивов равны 0.

Ну не знаю если вывести содержимое массива на экран то пустые ячейки выводятся как большое отрицательное число. Ну знаете как если бы я просто инициализировал переменную: int x; и потом вывел не положив никакого элемента std::cout<<x; Поэтому не факт что там будут нули.

Если инициализирован хотя бы один элемент, то все остальные будут заполнены нулями.

а если я присваиваю так?

Вообще-то, строго говоря, инициализацией является присвоение значения при определении объекта. Поэтому в приведенном ниже фрагменте кода

int a[] = { 1, 2, 3};

массив a инициализируется.
А в этом фрагменте

int a[3];
a[0] = 1; a[1] = 2; a[2] = 3;

происходит присвоение значений элементам неинициализированного массива.

Я под инициализацией понимал значение этого слова в его строгом смысле. Хотя распространено и такое его употребление, когда речь идет о присваивании значений объекту уже после его определения.

Если вы инициализируете массив при его определнии с помощью списка инициализации, то все элементы массива, которым не хватило инициализаторов, будут инициализированы 0.
То есть следующие два определения эквивалентны.

int a[3] = { 1, 0, 0 };

и

int a[3] = { 1 };

Если вы просто объявите массив не со статическим распределением памяти, то он будет содержать мусор. То есть если вы объявите локальный массив

int a[3];

то он может содержать любые значения в том числе и большие отрицательные числа, как вы пишите. То есть его содержимое не предсказуемо, а зависит от того, что хранилось в памяти на момент ее выделения для массива.

Поэтому вам просто нужно установить какое-то соглашение, при каком значении элемента массива этот элемент считается неинициализированным.

Просто порассуждайте логически. Вы говорили, что ваш массив содержал какие-то большие отрицательные числа. И это являлось следствием, как вы считаете. что массив не был проинициализирован. Но если эти числа могли содержаться в элементах массива, то почему программисту запрещено или не возможно присвоить эти значения элементам массива при его инициализации?

Ладно спасибо. Я разобрался=)

А хочешь, я угадаю, какое именно "большое отрицательное число" получилось?
-858993460
Нет?

Я бы не рекомендовал полагаться на такие "магические числа". Потому что это будет бесконечным источником багов.

(В скобках: мне приходилось в реальном проекте в коде видеть такое: Разумеется, это "работало" ровно до тех пор, пока не пришла пора поставлять заказчику релиз..... :-) Ну и попробуйте найти этот баг примерно в 500 КLOC....)

Ну и просто подскажу, что лучше не полагаться на компилятор, IDE или еще что-то и инициализировать любые массивы нулями (потом будет проще).

Статические подобным образом:
Динамические подобным: