ಅರೇ ಎನ್ನುವುದು ಒಂದೇ ರೀತಿಯ ಕೋಶಗಳ ಗುಂಪಿನಂತೆ ಪ್ರತಿನಿಧಿಸುವ ಡೇಟಾ ರಚನೆಯಾಗಿದ್ದು, ಒಂದೇ ಹೆಸರಿನಡಿಯಲ್ಲಿ ಒಂದುಗೂಡಿಸಲಾಗುತ್ತದೆ. ಒಂದೇ ರೀತಿಯ ದೊಡ್ಡ ಪ್ರಮಾಣದ ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅರೇಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ರಚನೆಯ ಹೆಸರು ಪಾಯಿಂಟರ್‌ಗಳು, ಸ್ವಲ್ಪ ಸಮಯದ ನಂತರ ನಾನು ನಿಮಗೆ ಹೇಳುತ್ತೇನೆ. ರಚನೆಯ ಪ್ರತ್ಯೇಕ ಡೇಟಾ ಕೋಶವನ್ನು ರಚನೆಯ ಅಂಶ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ರಚನೆಯ ಅಂಶಗಳು ಯಾವುದೇ ಪ್ರಕಾರದ ಡೇಟಾ ಆಗಿರಬಹುದು. ಅರೇಗಳು ಒಂದು ಅಥವಾ ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ಆಯಾಮಗಳನ್ನು ಹೊಂದಿರಬಹುದು. ಆಯಾಮಗಳ ಸಂಖ್ಯೆಯನ್ನು ಅವಲಂಬಿಸಿ, ಸರಣಿಗಳನ್ನು ಒಂದು ಆಯಾಮದ ಸರಣಿಗಳು, ಎರಡು ಆಯಾಮದ ಸರಣಿಗಳು, ಮೂರು-ಆಯಾಮದ ಸರಣಿಗಳು, ಮತ್ತು ಹೀಗೆ n-ಆಯಾಮದ ವ್ಯೂಹದವರೆಗೆ ವಿಂಗಡಿಸಲಾಗಿದೆ. ಪ್ರೋಗ್ರಾಮಿಂಗ್‌ನಲ್ಲಿ ಒಂದು ಆಯಾಮದ ಮತ್ತು ಎರಡು ಆಯಾಮದ ಸರಣಿಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ನಾವು ಈ ಸರಣಿಗಳನ್ನು ಮಾತ್ರ ಪರಿಗಣಿಸುತ್ತೇವೆ.

C++ ನಲ್ಲಿ ಒಂದು ಆಯಾಮದ ಅರೇಗಳು

ಒಂದು ಆಯಾಮದ ರಚನೆಯು ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರೂಪಿಸುವ ಒಂದು ನಿಯತಾಂಕವನ್ನು ಹೊಂದಿರುವ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ವಾಸ್ತವವಾಗಿ, ಒಂದು ಆಯಾಮದ ರಚನೆಯು ಕೇವಲ ಒಂದು ಸಾಲು ಮತ್ತು n ಸಂಖ್ಯೆಯ ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಒಂದು ಶ್ರೇಣಿಯಾಗಿದೆ. ಒಂದು ಆಯಾಮದ ರಚನೆಯಲ್ಲಿನ ಕಾಲಮ್‌ಗಳು ರಚನೆಯ ಅಂಶಗಳಾಗಿವೆ. ಚಿತ್ರ 1 ಒಂದು ಪೂರ್ಣಾಂಕದ ಒಂದು ಆಯಾಮದ ರಚನೆಯ ರಚನೆಯನ್ನು ತೋರಿಸುತ್ತದೆ ಎ. ಈ ರಚನೆಯ ಗಾತ್ರವು 16 ಕೋಶಗಳು.

ಚಿತ್ರ 1 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಗರಿಷ್ಠ ಸೂಚ್ಯಂಕ ಎಂಬುದನ್ನು ಗಮನಿಸಿ ಎ 15 ಆಗಿದೆ, ಆದರೆ ರಚನೆಯ ಗಾತ್ರವು 16 ಕೋಶಗಳು, ಏಕೆಂದರೆ ರಚನೆಯ ಕೋಶಗಳ ಸಂಖ್ಯೆಯು ಯಾವಾಗಲೂ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ. ಕೋಶ ಸೂಚ್ಯಂಕವು ಋಣಾತ್ಮಕವಲ್ಲದ ಪೂರ್ಣಾಂಕವಾಗಿದ್ದು, ಅದರ ಮೂಲಕ ನೀವು ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಕೋಶವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು ಮತ್ತು ಅದರ ಮೇಲೆ ಯಾವುದೇ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಬಹುದು ( ಕೋಶ).

//C++ ನಲ್ಲಿ ಒಂದು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸಲು ಸಿಂಟ್ಯಾಕ್ಸ್: /*ಡೇಟಾ ಪ್ರಕಾರ*/ /*ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಹೆಸರು*/; //ಚಿತ್ರ 1 ರಲ್ಲಿ ತೋರಿಸಿರುವ ಒಂದು ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವ ಉದಾಹರಣೆ: int a;

ಅಲ್ಲಿ, ಇಂಟ್ ಒಂದು ಪೂರ್ಣಾಂಕ;

A ಎಂಬುದು ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಹೆಸರು;
16 ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಗಾತ್ರ, 16 ಕೋಶಗಳು.

ರಚನೆಯ ಹೆಸರಿನ ನಂತರ ಯಾವಾಗಲೂ ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಗಾತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಚೌಕಾಕಾರದ ಆವರಣಗಳು ಇರುತ್ತವೆ;

//ಒಂದು ಆಯಾಮದ ಅರೇಗಳನ್ನು ಇಂಟ್ ಮಾಸ್ ಘೋಷಿಸಲು ಇನ್ನೊಂದು ಮಾರ್ಗ, a;

ಎರಡು ಒಂದು ಆಯಾಮದ ಅರೇಗಳು mas ಮತ್ತು a ಅನ್ನು ಕ್ರಮವಾಗಿ 10 ಮತ್ತು 16 ಗಾತ್ರಗಳೊಂದಿಗೆ ಘೋಷಿಸಲಾಗಿದೆ. ಇದಲ್ಲದೆ, ಈ ಘೋಷಣೆಯ ವಿಧಾನದಲ್ಲಿ, ಎಲ್ಲಾ ಸರಣಿಗಳು ಒಂದೇ ರೀತಿಯ ಡೇಟಾ ಪ್ರಕಾರವನ್ನು ಹೊಂದಿರುತ್ತವೆ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ - ಇಂಟ್.

ಘೋಷಿಸಿದಾಗ // ಸರಣಿಗಳನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಪ್ರಾರಂಭ

ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಪ್ರಾರಂಭವನ್ನು ಚಿಹ್ನೆಯ ನಂತರ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳಲ್ಲಿ ನಡೆಸಲಾಗುತ್ತದೆ ಸಮನಾಗಿರುತ್ತದೆ, ಪ್ರತಿ ರಚನೆಯ ಅಂಶವನ್ನು ಹಿಂದಿನದರಿಂದ ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಲಾಗಿದೆ.

ಇಂಟ್ a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // ಅದರ ಗಾತ್ರವನ್ನು ನಿರ್ಧರಿಸದೆ ರಚನೆಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು.

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕಂಪೈಲರ್ ಸ್ವತಃ ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಗಾತ್ರವನ್ನು ನಿರ್ಧರಿಸುತ್ತದೆ. ಅರೇ ಅನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಘೋಷಿಸುವಾಗ ಅದರ ಗಾತ್ರವನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು, ರಚನೆಯ ಗಾತ್ರವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು. ಒಂದು ಆಯಾಮದ ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸರಳವಾದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸೋಣ.

// array.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು << "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } system("pause"); return 0; }

// ಕೋಡ್ ಕೋಡ್:: ಬ್ಲಾಕ್‌ಗಳು

// ದೇವ್-ಸಿ++ ಕೋಡ್

// array.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) (ಕೌಟ್<< "obrabotka massiva" << endl; int array1 = { 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 }; // объявление и инициализация одномерного массива cout << "indeks" << "\t\t" << "element massiva" << endl; // печать заголовков for (int counter = 0; counter < 16; counter++) //начало цикла { //вывод на экран индекса ячейки массива, а затем содержимого этой ячейки, в нашем случае - это целое число cout << "array1[" << counter << "]" << "\t\t" << array1 << endl; } return 0; }

IN ಸಾಲುಗಳು 10-11 array1 ಹೆಸರಿನ ಪೂರ್ಣಾಂಕದ ಒಂದು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸಲಾಗಿದೆ ಮತ್ತು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಅದರ ಗಾತ್ರವು 16 ಕೋಶಗಳು, ಅಂದರೆ, ಅಂತಹ ಒಂದು ಶ್ರೇಣಿಯು 16 ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು. ಯಾವುದೇ ರಚನೆಯ ಪ್ರಕ್ರಿಯೆಯು ಲೂಪ್‌ಗಳ ಜೊತೆಯಲ್ಲಿ ಮಾತ್ರ ಸಾಧ್ಯ. ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಯಾವ ಲೂಪ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವುದು ನಿಮಗೆ ನಿರ್ಧರಿಸಲು ಬಿಟ್ಟದ್ದು. ಆದರೆ ಈ ಕಾರ್ಯಕ್ಕೆ ಇದು ಸೂಕ್ತವಾಗಿರುತ್ತದೆ. ಒಂದು ಆಯಾಮದ ರಚನೆಯ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ನಾವು ಕೌಂಟರ್ ವೇರಿಯಬಲ್ ಕೌಂಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ಫಾರ್ ಲೂಪ್ ಅನ್ನು ಮುಂದುವರಿಸುವ ಸ್ಥಿತಿಯು ಕಟ್ಟುನಿಟ್ಟಾದ ಅಸಮಾನತೆಯ ಚಿಹ್ನೆಯನ್ನು ಹೊಂದಿದೆ, ಏಕೆಂದರೆ ಏಕ-ಆಯಾಮದ ಅರೇ ಅರೇ 1 ನಲ್ಲಿ ಹದಿನಾರನೇ ಸೂಚ್ಯಂಕ ಇಲ್ಲ. ಮತ್ತು ಕೋಶಗಳ ಸಂಖ್ಯೆಯು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುವುದರಿಂದ, ಫಾರ್ ಲೂಪ್‌ನ ದೇಹದಲ್ಲಿ 16 ಅಂಶಗಳಿವೆ, ಕೌಟ್ ಆಪರೇಟರ್ ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಮುದ್ರಿಸುತ್ತದೆ (ಚಿತ್ರ 2 ನೋಡಿ).

ಒಬ್ರಬೊಟ್ಕಾ ಮಾಸ್ಸಿವಾ ಇಂಡೆಕ್ಸ್ ಎಲಿಮೆಂಟ್ ಮಾಸ್ಸಿವಾ ಅರೇ1 5 ಅರೇ1 -12 ಅರೇ1 -12 ಅರೇ1 9 ಅರೇ1 10 ಅರೇ1 0 ಅರೇ1 -9 ಅರೇ ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. . .

ಚಿತ್ರ 2 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

C++ ನಲ್ಲಿ ಒಂದು ಆಯಾಮದ ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತೊಂದು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸೋಣ. ಪ್ರೋಗ್ರಾಂ ಕೀಬೋರ್ಡ್‌ನಿಂದ ನಮೂದಿಸಿದ ಹತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ಓದಬೇಕು. ನಮೂದಿಸಿದ ಎಲ್ಲಾ ಸಂಖ್ಯೆಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಫಲಿತಾಂಶವನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

// array_sum.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು << "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> << "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; system("pause"); return 0; }

// ಕೋಡ್ ಕೋಡ್:: ಬ್ಲಾಕ್‌ಗಳು

// ದೇವ್-ಸಿ++ ಕೋಡ್

// array_sum.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) ( int array1; // ಒಂದು ಪೂರ್ಣಾಂಕ ಅರೇ ಕೌಟ್ ಅನ್ನು ಘೋಷಿಸಿ<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> ಶ್ರೇಣಿ1; // ಕೀಬೋರ್ಡ್ ಕೌಟ್‌ನಿಂದ ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಗಳನ್ನು ಓದಿ<< "array1 = {"; for (int counter = 0; counter < 10; counter++) // цикл для вывода элементов массива cout << array1 << " "; // выводим элементы массива на стандартное устройство вывода for (int counter = 0; counter < 10; counter++) // цикл для суммирования чисел массива sum += array1; // суммируем элементы массива cout << "}\nsum = " << sum << endl; return 0; }

ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವ ಮೊದಲು, ಅದನ್ನು ಘೋಷಿಸಬೇಕು ಮತ್ತು ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಗಾತ್ರವು 10 ಆಗಿದೆ, ಏಕೆಂದರೆ ಇದು ಕಾರ್ಯದ ಸ್ಥಿತಿಯಿಂದ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮೊತ್ತ ವೇರಿಯೇಬಲ್‌ನಲ್ಲಿ ನಾವು ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳ ಮೊತ್ತವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ಲೂಪ್‌ಗಾಗಿ ಮೊದಲನೆಯದು ಕೀಬೋರ್ಡ್‌ನಿಂದ ನಮೂದಿಸಿದ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ಡಿಕ್ಲೇರ್ಡ್ ಏಕ-ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ತುಂಬುತ್ತದೆ, ಸಾಲುಗಳು 12-13. ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಅನುಕ್ರಮವಾಗಿ ಏಕ-ಆಯಾಮದ ಅರೇ 1 ರ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ, ಇದು ಸೂಚ್ಯಂಕ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗಿ 9 ನೇ ವರೆಗೆ. ಲೂಪ್‌ಗಾಗಿ ಎರಡನೆಯದು ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ, ಸಾಲುಗಳು 15-16. ಮೂರನೇ ಫಾರ್ ಲೂಪ್ ಅನುಕ್ರಮವಾಗಿ ಒಂದು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಓದುತ್ತದೆ ಮತ್ತು ಅವುಗಳನ್ನು ಒಟ್ಟುಗೂಡಿಸುತ್ತದೆ, ಮೊತ್ತವನ್ನು ಮೊತ್ತ ವೇರಿಯಬಲ್‌ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ. ಸಾಲುಗಳು 17-18. ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶವನ್ನು ಚಿತ್ರ 3 ರಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ.

ಎಲಿಮೆಂಟಿ ಮಾಸ್ಸಿವಾ ನಮೂದಿಸಿ: 0 1 2 3 4 5 6 7 8 9 ಅರೇ1 = (0 1 2 3 4 5 6 7 8 9 ) ಮೊತ್ತ = 45 ಮುಂದುವರಿಸಲು, ಯಾವುದೇ ಕೀಲಿಯನ್ನು ಒತ್ತಿರಿ. . .

ಚಿತ್ರ 3 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

ಮೊದಲಿಗೆ, ಎಲ್ಲಾ 10 ಸಂಖ್ಯೆಗಳನ್ನು ಅನುಕ್ರಮವಾಗಿ ನಮೂದಿಸಲಾಗಿದೆ, ಅದರ ನಂತರ ಒಂದು ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ರಚನೆಯಲ್ಲಿನ ಸಂಖ್ಯೆಗಳ ಮೊತ್ತವನ್ನು ಮುದ್ರಿಸಲಾಗುತ್ತದೆ.

C++ ನಲ್ಲಿ ಎರಡು ಆಯಾಮದ ಅರೇಗಳು

ಈ ಹಂತದವರೆಗೆ, ನಾವು ಏಕ ಆಯಾಮದ ಸರಣಿಗಳನ್ನು ಪರಿಗಣಿಸಿದ್ದೇವೆ, ಅದನ್ನು ಯಾವಾಗಲೂ ಸೀಮಿತಗೊಳಿಸಲಾಗುವುದಿಲ್ಲ. ನೀವು ಟೇಬಲ್‌ನಿಂದ ಕೆಲವು ಡೇಟಾವನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬೇಕು ಎಂದು ಹೇಳೋಣ. ಟೇಬಲ್ ಎರಡು ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹೊಂದಿದೆ: ಸಾಲುಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಕಾಲಮ್ಗಳ ಸಂಖ್ಯೆ. ಎರಡು ಆಯಾಮದ ರಚನೆಯಲ್ಲಿ, ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯ ಜೊತೆಗೆ, ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲುಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯಂತಹ ಗುಣಲಕ್ಷಣಗಳಿವೆ. ಅಂದರೆ, ದೃಷ್ಟಿಗೋಚರವಾಗಿ, ಎರಡು ಆಯಾಮದ ರಚನೆಯು ಸಾಲುಗಳು ಮತ್ತು ಕಾಲಮ್‌ಗಳೊಂದಿಗೆ ಸಾಮಾನ್ಯ ಕೋಷ್ಟಕವಾಗಿದೆ. ವಾಸ್ತವವಾಗಿ, ಎರಡು ಆಯಾಮದ ರಚನೆಯು ಒಂದು ಆಯಾಮದ ಸರಣಿಗಳ ಒಂದು ಆಯಾಮದ ಸರಣಿಯಾಗಿದೆ. ಎರಡು ಆಯಾಮದ ರಚನೆಯ ರಚನೆಯನ್ನು, a ಹೆಸರಿನಿಂದ, n ನಿಂದ m ಗಾತ್ರವನ್ನು ಕೆಳಗೆ ತೋರಿಸಲಾಗಿದೆ (ಚಿತ್ರ 4 ನೋಡಿ).

ಚಿತ್ರ 4 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

ಇಲ್ಲಿ, m ಎಂಬುದು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲುಗಳ ಸಂಖ್ಯೆ;
n ಎಂಬುದು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ;
m * n - ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ.

// ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸಲು ಸಿಂಟ್ಯಾಕ್ಸ್ /*ಡೇಟಾ ಪ್ರಕಾರ*/ /*ಅರೇ ಹೆಸರು*/;

ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸುವಲ್ಲಿ, ಹಾಗೆಯೇ ಒಂದು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸುವಲ್ಲಿ, ಮೊದಲನೆಯದಾಗಿ, ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕಾಗಿದೆ:

• ಡೇಟಾ ಪ್ರಕಾರ;
• ರಚನೆಯ ಹೆಸರು.

ಅದರ ನಂತರ, ಮೊದಲ ಚದರ ಆವರಣಗಳು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತವೆ ಮತ್ತು ಎರಡನೇ ಚದರ ಆವರಣಗಳು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಕಾಲಮ್ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತವೆ. ಎರಡು ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ದೃಷ್ಟಿಗೋಚರವಾಗಿ ಒಂದು ಆಯಾಮದ ರಚನೆಯಿಂದ ಎರಡನೇ ಜೋಡಿ ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾಗಿದೆ. ಎರಡು ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ. ನಾವು 15 ಕ್ಕೆ ಸಮಾನವಾದ ಹಲವಾರು ಅಂಶಗಳೊಂದಿಗೆ ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಘೋಷಿಸಬೇಕಾಗಿದೆ ಎಂದು ಹೇಳೋಣ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಎರಡು ಆಯಾಮದ ರಚನೆಯು ಮೂರು ಸಾಲುಗಳು ಮತ್ತು ಐದು ಕಾಲಮ್ಗಳು ಅಥವಾ ಐದು ಸಾಲುಗಳು ಮತ್ತು ಮೂರು ಕಾಲಮ್ಗಳನ್ನು ಹೊಂದಬಹುದು.

// ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಉದಾಹರಣೆ ಘೋಷಣೆ: int a;

• a ಎಂಬುದು ಪೂರ್ಣಾಂಕ ರಚನೆಯ ಹೆಸರು
• ಮೊದಲ ಚದರ ಆವರಣದಲ್ಲಿರುವ ಸಂಖ್ಯೆಯು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ 5 ಇವೆ;
• ಎರಡನೇ ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ಸಂಖ್ಯೆಯು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಈ ಸಂದರ್ಭದಲ್ಲಿ 3 ಇವೆ.

// ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಪ್ರಾರಂಭ: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

ಈ ರಚನೆಯು 5 ಸಾಲುಗಳು, 3 ಕಾಲಮ್‌ಗಳನ್ನು ಹೊಂದಿದೆ. ನಿಯೋಜನೆ ಚಿಹ್ನೆಯ ನಂತರ, ಸಾಮಾನ್ಯ ಕರ್ಲಿ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ, ಅದರೊಳಗೆ ಎರಡು ಆಯಾಮದ ರಚನೆಯಲ್ಲಿ ರೇಖೆಗಳು ಇರಬೇಕಾದಷ್ಟು ಜೋಡಿ ಸುರುಳಿಯಾಕಾರದ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು ಇರಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ಬ್ರಾಕೆಟ್‌ಗಳನ್ನು ಅಲ್ಪವಿರಾಮದಿಂದ ಬೇರ್ಪಡಿಸಲಾಗುತ್ತದೆ. ಪ್ರತಿಯೊಂದು ಜೋಡಿ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳಲ್ಲಿ, ಅಲ್ಪವಿರಾಮದಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾದ ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಬರೆಯಿರಿ. ಎಲ್ಲಾ ಸುರುಳಿಯಾಕಾರದ ಕಟ್ಟುಪಟ್ಟಿಗಳಲ್ಲಿ, ಅಂಶಗಳ ಸಂಖ್ಯೆಯು ಒಂದೇ ಆಗಿರಬೇಕು. ರಚನೆಯಲ್ಲಿ ಐದು ಸಾಲುಗಳಿರುವುದರಿಂದ, ಐದು ಆಂತರಿಕ ಜೋಡಿ ಬ್ರಾಕೆಟ್‌ಗಳೂ ಇವೆ. ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ ಮೂರು ಆಗಿರುವುದರಿಂದ ಮೂರು ಅಂಶಗಳನ್ನು ಒಳ ಆವರಣಗಳಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ. ಸಚಿತ್ರವಾಗಿ, ನಮ್ಮ ರಚನೆಯು ಎರಡು ಆಯಾಮದ ಕೋಷ್ಟಕದಂತೆ ಕಾಣುತ್ತದೆ (ಚಿತ್ರ 5 ನೋಡಿ).

ಚಿತ್ರ 5 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಪ್ರತಿ ಕೋಶದಲ್ಲಿ ಎಮೌಲ್ಯವನ್ನು ತೋರಿಸಲಾಗಿದೆ, ಈ ಕೋಶದ ವಿಳಾಸವನ್ನು ಕೆಳಗಿನ ಬಲ ಮೂಲೆಯಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸೆಲ್ ವಿಳಾಸವು ರಚನೆಯ ಹೆಸರು, ಸಾಲು ಸಂಖ್ಯೆ ಮತ್ತು ಕಾಲಮ್ ಸಂಖ್ಯೆಯಾಗಿದೆ.

"ಲ್ಯಾಬಿರಿಂತ್" ಎಂಬ ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಸರಳವಾದ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸೋಣ. ಚಕ್ರವ್ಯೂಹವನ್ನು ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಆಧಾರದ ಮೇಲೆ ನಿರ್ಮಿಸಬೇಕು. ನಮ್ಮ ವಿವೇಚನೆಯಿಂದ ನಾವು ಚಕ್ರವ್ಯೂಹದ ಗಾತ್ರವನ್ನು ಆಯ್ಕೆ ಮಾಡುತ್ತೇವೆ.

// array2.cpp: ಕನ್ಸೋಲ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಾಗಿ ಪ್ರವೇಶ ಬಿಂದುವನ್ನು ವಿವರಿಸುತ್ತದೆ. #ಸೇರಿಸು "stdafx.h" #ಸೇರಿಸು < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castಕೌಟ್<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// ಕೋಡ್ ಕೋಡ್:: ಬ್ಲಾಕ್‌ಗಳು

// ದೇವ್-ಸಿ++ ಕೋಡ್

(176); ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main(int argc, char* argv) ( // 1-ಷರತ್ತುಬದ್ಧವಾಗಿ “ಮೇಜ್‌ನ ಗೋಡೆಗಳು” // 2-“ಸರಿಯಾದ ಮಾರ್ಗ, ಜಟಿಲದಿಂದ ನಿರ್ಗಮಿಸಿ” // 0-“ತಪ್ಪು ಮಾರ್ಗ” ಇಂಟ್ ಮಾಸ್ = (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಪ್ರಾರಂಭ ( 1,2,1,0 ,0,1,0,1,2,2,2,1,1,1,1,0,0,0,0,1,), (1,2,1,1 ,0,1,0, 1,2,1,2,2,2,2,1,0,1,1,0,1,), (1,2,2,2,2,2,2, 1,2,1,1 ,1,1,2,1,0,0,1,0,1,), (1,1,1,1,1,1,2,1,2,1,0 ,0,1,2, 1,1,0,1,0,1,), (1,0,0,1,0,0,2,2,2,1,1,0,0,2, 0,0,0,1 ,0,1,), (1,0,1,1,0,1,1,1,1,1,0,0,1,2,1,1,1,1 ,0,1,), (1,0,0,0,0,0,0,0,0,1,1,1,1,2,1,0,0,0,0,0,1,) (1,1,1, 1,1,1,0,1,1,1,2,2,2,2,1,0,1,1,1,1,), (1,1,0, 0,0,1,0 ,0,1,1,2,1,1,1,1,1,0,0,0,0,1,), (1,0,0,1,0,0,0 ,0,0,1, 2,2,2,2,1,1,1,1,0,1,), (1,1,1,1,1,1,1,1,1,1,1, 1,1,1,2 ,1,0,0,0,0,1,), (1,2,2,2,2,2,2,2,2,2,2,2,2,2,2 ,1,0,1, 1,1,1,), (1,2,1,1,0,1,1,1,1,1,1,1,1,1,1,1,0,0, 0,0,1,) , (1,2,1,0,0,0,1,2,2,2,1,0,0,0,0,0,1,1,0,1,) , (1,2,1 ,1,1,1,1,2,1,2,1,1,1,0,1,0,0,0,0,1,), (1,2,1 ,2,2,2, 1,2,1,2,2,2,1,1,1,1,1,1,1,1,), (1,2,1,2,1,2, 1,2,1,0 ,1,2,2,2,2,2,2,2,2,1,), (1,2,1,2,1,2,1,2,1,0 ,1,1,1, 1,1,1,1,1,2,1,), (1,2,1,2,1,2,1,2,1,0,0,0,0, 0,0,0,0 ,0,2,1,), (1,2,1,2,1,2,2,2,1,0,1,1,1,1,1,1,1,0 ,1,2,1, ), (1,2,1,2,1,1,1,1,1,1,0,0,0,1,0,1,0,0,1,2,1, ), (1,2, 1,2,2,1,0,0,1,1,1,1,0,0,0,1,0,1,1,2,1,), (1,2, 1,1,2,1 ,1,0,0,0,0,0,1,0,1,0,0,1,2,1,), (1,2,1,1,2,1 ,0,0,1, 1,1,1,1,1,1,1,1,1,1,2,1,), (1,2,1,1,2,1,1,0,1, 2,2,2,2 ,2,2,2,2,2,2,1,), (1,2,1,1,2,1,0,0,1,2,1,1,1 ,1,1,1, 1,1,1,1,), (1,2,1,1,2,1,0,1,1,2,1,1,1,1,1,1, 1,1,2,2 ,), (1,2,1,1,2,1,0,0,1,2,1,1,2,2,2,2,2,2,2,2,1 ,), (1,2 ,1,1,2,1,0,1,1,2,1,1,2,1,1,1,1,1,1,1,), (1,2 ,1,1,2, 1,0,0,1,2,1,1,2,1,0,0,0,1,0,1,), (1,2,2,2,2, 1,0,1,1 ,2,2,2,2,0,0,1,0,0,0,1,), (1,1,1,1,1,1,1,1,1 ,1,1,1, 1,1,1,1,1,1,1,1,) ); // ಎರಡು ಕುಣಿಕೆಗಳು - ಆಂತರಿಕ ಮತ್ತು ಬಾಹ್ಯ, ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸುವುದು (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176);<< static_castಕೌಟ್<< " "; // вывести два пробела cout << endl; } return 0; }

ಸರಿಯಾದ ಮತ್ತು ತಪ್ಪು ಮಾರ್ಗಗಳನ್ನು ಒಂದೇ ಸಂಖ್ಯೆಯಿಂದ ಸೂಚಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, ಶೂನ್ಯ, ಆದರೆ ಸ್ಪಷ್ಟತೆಗಾಗಿ, ಸರಿಯಾದ ಮಾರ್ಗವನ್ನು ಸಂಖ್ಯೆ 2 ರಿಂದ ಸೂಚಿಸಲಾಗುತ್ತದೆ. ಸರಣಿಯನ್ನು ಕೈಯಾರೆ ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ಸರಳೀಕರಿಸಲು ಮಾತ್ರ. ಪ್ರೋಗ್ರಾಂ ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುವುದರಿಂದ, ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಅಂಶಗಳ ನಡುವೆ ಬದಲಾಯಿಸಲು ಎರಡು ಕುಣಿಕೆಗಳು ಅಗತ್ಯವಿದೆ. ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲುಗಳ ನಡುವೆ ಲೂಪ್ ಸ್ವಿಚ್‌ಗಳಿಗೆ ಮೊದಲನೆಯದು. ಎರಡು ಆಯಾಮದ ಸರಣಿಯಲ್ಲಿ 33 ಸಾಲುಗಳಿರುವುದರಿಂದ, ಕೌಂಟರ್ ವೇರಿಯೇಬಲ್ i ಅನ್ನು 0 ರಿಂದ 33 ಕ್ಕೆ ಹೆಚ್ಚಿಸಲಾಗಿದೆ, ಸಾಲು 46. ಮೊದಲ ಲೂಪ್ ಒಳಗೆ ಎರಡು ಆಯಾಮದ ರಚನೆಯ ಸಾಲು ಅಂಶಗಳ ಮೂಲಕ ಆವರ್ತಿಸುವ ಫಾರ್ ಲೂಪ್ ಆಗಿದೆ. ಲೂಪ್‌ಗಾಗಿ ಸೆಕೆಂಡ್‌ನ ದೇಹದಲ್ಲಿ, ಏಕೀಕೃತ ಡೇಟಾ ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಒಳಗೆ ನಡೆಸಲಾಗುತ್ತದೆ - ಸ್ಟ್ಯಾಟಿಕ್_ಕಾಸ್ಟ್<>() , ಇದು ಅಕ್ಷರ ಸಂಖ್ಯೆ 176 ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. ಡೇಟಾ ಪ್ರಕಾರದ ಪರಿವರ್ತನೆ ಕಾರ್ಯಾಚರಣೆಯನ್ನು ಜಟಿಲ ಅಗಲವನ್ನು ಹೆಚ್ಚಿಸಲು ನಕಲು ಮಾಡಲಾಗಿದೆ. ಕಾರ್ಯಕ್ರಮದ ಫಲಿತಾಂಶ (ಚಿತ್ರ 6 ನೋಡಿ).

ಚಿತ್ರ 6 - ಸಿ++ ನಲ್ಲಿ ಅರೇಗಳು

ಒಂದೇ ರೀತಿಯ ಬಹು ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಅರೇಗಳನ್ನು ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಫ್ಯಾರನ್‌ಹೀಟ್‌ನಿಂದ ಸೆಲ್ಸಿಯಸ್ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ, ನಾವು ಮೂರರಲ್ಲಿ ಸರಾಸರಿ ತಾಪಮಾನ ಮೌಲ್ಯವನ್ನು ಲೆಕ್ಕ ಹಾಕಿದ್ದೇವೆ. ಮೂರು ಮೌಲ್ಯಗಳು ಇಲ್ಲದಿದ್ದರೆ, ಆದರೆ ಹೆಚ್ಚು ಇದ್ದರೆ, ಇಲ್ಲಿ ನೀವು ಸರಣಿಗಳನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ.

ನೀವು ರಚನೆಯನ್ನು ಬಳಸುವ ಮೊದಲು, ನೀವು ಅದನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಬೇಕಾಗಿದೆ. ರಚನೆಯ ವ್ಯಾಖ್ಯಾನವು ಒಳಗೊಂಡಿದೆ: ರಚನೆಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾದ ಪ್ರಕಾರ, ರಚನೆಯ ಹೆಸರು ಮತ್ತು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ:

ಇಂಟ್ ಅರೇ;

ಈ ಕೋಡ್‌ನಲ್ಲಿ, ಟೈಪ್ ಇಂಟ್‌ನ ಹತ್ತು ಅಂಶಗಳ ಐಡೆಂಟಿಫೈಯರ್ (ಹೆಸರು) ರಚನೆಯೊಂದಿಗೆ ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿದ್ದೇವೆ.
ಈ ರೂಪದಲ್ಲಿ, ರಚನೆಯ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ಇನ್ನೂ ಪ್ರಾರಂಭಿಸಲಾಗಿಲ್ಲ. ಘೋಷಿಸಿದಾಗ ಅವುಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲು, ನೀವು ಈ ಕೆಳಗಿನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ:

ಇಂಟ್ ಅರೇ = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ರಚನೆಯ ಮೊದಲ ಅಂಶಕ್ಕೆ 0 ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಮತ್ತು ಕೊನೆಯ ಅಂಶಕ್ಕೆ ಮೌಲ್ಯ 9 ಅನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ.
ರಚನೆಯ ಅಂಶಗಳಿಗೆ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಲು ನೀವು ಲೂಪ್ಗಳನ್ನು ಬಳಸಬಹುದು. ಇದಕ್ಕೆ ಅತ್ಯಂತ ಸೂಕ್ತವಾದದ್ದು ಫಾರ್ ಲೂಪ್ ಆಗಿರುತ್ತದೆ.

ಸಿ ++ ಕೋಡ್ಇಂಟ್ ಅರೇ; (int i = 0; i. ಗಾಗಿ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನ< 10; i++) { array[i] = i; }

ಇಲ್ಲಿ ನಾವು ಸರಣಿಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಸೂಚ್ಯಂಕದ ಮೂಲಕ ಪ್ರವೇಶಿಸುತ್ತೇವೆ - ಚೌಕ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ಸಂಖ್ಯೆ. ಲೂಪ್ನ ಪ್ರತಿ ಪುನರಾವರ್ತನೆಯೊಂದಿಗೆ, ಇದು ಶೂನ್ಯದಿಂದ 9 ರವರೆಗಿನ ಮೌಲ್ಯಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆಯು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಆದ್ದರಿಂದ, ಸೂಚ್ಯಂಕಗಳ ಸಂಖ್ಯೆಯು ಯಾವಾಗಲೂ ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಗಿಂತ ಒಂದು ಕಡಿಮೆಯಿರುತ್ತದೆ.

ಸ್ಕ್ವೇರ್ ಬ್ರಾಕೆಟ್‌ಗಳು ಮತ್ತು ಸಬ್‌ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳನ್ನು ಹೊರತುಪಡಿಸಿ, ಯಾವುದೇ ವೇರಿಯೇಬಲ್‌ನಂತೆ ಅರೇ ಅಂಶವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ.

ತಂತಿಗಳು

ಇಲ್ಲಿಯವರೆಗೆ, ನಾವು ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಸ್ಥಿರಾಂಕಗಳಲ್ಲಿ ಮಾತ್ರ ಸಂಗ್ರಹಿಸಬಹುದು: "ಸ್ಥಿರ ಸ್ಟ್ರಿಂಗ್‌ನ ಉದಾಹರಣೆ." ನಾವು ವೇರಿಯೇಬಲ್‌ಗಳಲ್ಲಿ ಒಂದು ಅಕ್ಷರವನ್ನು ಮಾತ್ರ ಸಂಗ್ರಹಿಸಬಹುದು - ಚಾರ್ ಪ್ರಕಾರದಲ್ಲಿ. C++ ಎರಡು ವಿಧದ ತಂತಿಗಳನ್ನು ಬಳಸುತ್ತದೆ: ಪ್ರಕಾರದ ಚಾರ್ ಮತ್ತು ಟೈಪ್ str ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿ. ಈಗ ನಾವು ಮೊದಲ ಆಯ್ಕೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕರಿಸುತ್ತೇವೆ.

ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ನಮಗೆ ಒಂದು ಶ್ರೇಣಿಯ ಅಗತ್ಯವಿದೆ. ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಚಾರ್ ಸ್ಟ್ರಿಂಗ್ = ("s","t","p","o"."k","a");

ಅದೃಷ್ಟವಶಾತ್ ಸುಲಭವಾದ ಮಾರ್ಗವಿದೆ :)

ಚಾರ್ ಸ್ಟ್ರಿಂಗ್ = "ಸ್ಟ್ರಿಂಗ್";

ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಏಳು ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ರಚಿಸಲಾಗುತ್ತದೆ. ಏಳರಲ್ಲಿ ಏಕೆ? ಪಾಯಿಂಟ್ ಎಂದರೆ ಪ್ರತಿ ಸಾಲು ಖಾಲಿ ಬೈಟ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಅಕ್ಷರ ಸ್ಥಿರ "\0" ನೊಂದಿಗೆ ಕೊನೆಗೊಳ್ಳಬೇಕು.

ಹಿಂದಿನ ಉದಾಹರಣೆಗಳಲ್ಲಿ, ನಾವು ಆರು ಅಕ್ಷರಗಳಿಗಿಂತ ಹೆಚ್ಚಿನ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಅರೇಗೆ ನಮೂದಿಸಲು ಪ್ರಯತ್ನಿಸಿದರೆ, ಸರಣಿಯು ಉಕ್ಕಿ ಹರಿಯುತ್ತದೆ ಏಕೆಂದರೆ ಪ್ರೋಗ್ರಾಂ ಚಾಲನೆಯಲ್ಲಿರುವಾಗ ನೀವು ರಚನೆಯ ಗಾತ್ರವನ್ನು ಬದಲಾಯಿಸಲಾಗುವುದಿಲ್ಲ (ಯಾವಾಗಲೂ ಅಲ್ಲ):

ಚಾರ್ ಸ್ಟ್ರಿಂಗ್; // ಸ್ಟ್ರಿಂಗ್ ಆರು ಅಕ್ಷರಗಳನ್ನು ಮತ್ತು "\0" ಅನ್ನು ಸಂಗ್ರಹಿಸಬಹುದು

ಸ್ಟ್ರಿಂಗ್ = "ಸ್ಟ್ರಿಂಗ್!"; // ಸಾಲು ಏಳು ಅಕ್ಷರಗಳನ್ನು ಒಳಗೊಂಡಿದೆ
ಇದನ್ನು ಮಾಡಲು ಶಿಫಾರಸು ಮಾಡುವುದಿಲ್ಲ :)

ನಾನು ನಿಮ್ಮ ಗಮನವನ್ನು ಸೆಳೆಯಲು ಬಯಸುವ ಇನ್ನೊಂದು ಅಂಶವಿದೆ. ಬಳಕೆದಾರರು ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ನಮೂದಿಸಿದಾಗ, ಸ್ಪೇಸ್‌ಗಳನ್ನು "\0" ಎಂದು ಪರಿಗಣಿಸಲಾಗುತ್ತದೆ. ನಾವು ಇನ್ನೂ ನಮ್ಮ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ನಮೂದಿಸುವುದಿಲ್ಲ, ಆದ್ದರಿಂದ ನಾನು ಈ ಪ್ರಕರಣವನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸುವುದಿಲ್ಲ.

ಅರೇಗಳ ಅರೇಗಳು (ಎರಡು ಆಯಾಮದ ಅರೇಗಳು)

ಸರಿ, ಅಂತಿಮವಾಗಿ ನಾವು ಈ ಸಂಚಿಕೆಯಲ್ಲಿ ಪ್ರಮುಖ ವಿಷಯಕ್ಕೆ ಬರುತ್ತೇವೆ.

ಕಾರ್ಯತಂತ್ರದ (ಮತ್ತು ಕೇವಲ) ಆಟಗಳಲ್ಲಿ (ಆರ್ಟಿಎಸ್) ನಕ್ಷೆಯನ್ನು ಕೋಶಗಳಾಗಿ ವಿಂಗಡಿಸಲಾಗಿದೆ (ಇಂಗ್ಲಿಷ್ನಲ್ಲಿ - ಟೈಲ್). ಎರಡು ಆಯಾಮದ ಶ್ರೇಣಿಯನ್ನು ಬಳಸಿಕೊಂಡು ಈ ಕೋಶಗಳನ್ನು ಪ್ರತಿನಿಧಿಸಲು ಅನುಕೂಲಕರವಾಗಿದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಸ್ಯೂಡೋ_ಗೇಮ್ ಪ್ರೋಗ್ರಾಂನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವುದನ್ನು ಮುಂದುವರಿಸುತ್ತೇವೆ ಮತ್ತು ಎರಡು ಆಯಾಮದ ರಚನೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ಆಟಗಾರನು ಚಲಿಸಬಹುದಾದ ನಕ್ಷೆಯನ್ನು ನಾವು ಅನುಕರಿಸುತ್ತೇವೆ. ಇಲ್ಲಿಯವರೆಗೆ, "ಚಲನೆ" ಅನ್ನು x, y ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಬಳಸಿ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

ನಾವು ಕೋಶಗಳನ್ನು ಚಿಹ್ನೆಗಳೊಂದಿಗೆ ಪ್ರತಿನಿಧಿಸುತ್ತೇವೆ. "ಕಾರ್ಡ್" ನ ಗಾತ್ರವು 15x20 ಆಗಿದೆ. ಹದಿನೈದು ಎತ್ತರ, ಇಪ್ಪತ್ತು ಅಗಲ. ನಾವು T ಚಿಹ್ನೆಯಿಂದ ಆಟಗಾರನನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತೇವೆ.

ಮೊದಲು ಹೆಡರ್ ಫೈಲ್ ಅನ್ನು ಸೇರಿಸಿ stdlib.h

ಸುಧಾರಿತ ಹುಸಿ_ಆಟ

ನಾನು ಕೋಡ್ ತುಣುಕುಗಳನ್ನು ಮಾತ್ರ ನೀಡುತ್ತೇನೆ. ನಿಮ್ಮ ಕಣ್ಣುಗಳ ಮುಂದೆ ಪೂರ್ಣ ಕಾರ್ಯಕ್ರಮವನ್ನು ಹೊಂದಲು ಸಲಹೆ ನೀಡಲಾಗುತ್ತದೆ. ನೀವು ಅದನ್ನು "ಪ್ರೋಗ್ರಾಂ ಪಟ್ಟಿಗಳು" ವಿಭಾಗದಲ್ಲಿ ಕಾಣಬಹುದು - pseudo_game_0_2. ಇದು ಕಂಪೈಲ್ ಮತ್ತು ರನ್ ಆಗುತ್ತದೆ. ಅದನ್ನು ನಿಮ್ಮ IDE ನ ಸಂಪಾದಕಕ್ಕೆ ನಕಲಿಸಿ ಮತ್ತು ಪಠ್ಯವನ್ನು ಅನುಸರಿಸಿ.

ಡೇಟಾ ಆರಂಭ:

ಸಿ ++ ಕೋಡ್ಚಾರ್ ಆಕ್ಟ್; // ಬಳಕೆದಾರ ಇನ್‌ಪುಟ್ ಇಂಟ್ ch ಓದಲು ವೇರಿಯೇಬಲ್; // ವೇರಿಯಬಲ್ ಆಕ್ಟ್ ಇಂಟ್ x = 0 ನ ಕಡಿಮೆ ಮೌಲ್ಯವನ್ನು ಸಂಗ್ರಹಿಸಲು ವೇರಿಯಬಲ್; // ಆಟಗಾರನ ನಿರ್ದೇಶಾಂಕಗಳನ್ನು ಇಂಟ್ y = 0 ಸಂಗ್ರಹಿಸಲು ಎರಡು ವೇರಿಯಬಲ್‌ಗಳು; ಚಾರ್ ನಕ್ಷೆ; // ಗೇಮ್ ಕಾರ್ಡ್ ಅನ್ನು ಸಂಗ್ರಹಿಸಲು ಅರೇ // (int i = 0; i ಗಾಗಿ ಶ್ರೇಣಿಯನ್ನು ಪ್ರಾರಂಭಿಸುವುದು< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

ಇಲ್ಲಿ, ನಮಗೆ ಹೊಸ ಆಪರೇಟರ್ ಎರಡು ಆಯಾಮದ ರಚನೆಯ ವ್ಯಾಖ್ಯಾನವಾಗಿದೆ. ಆದರೆ ಇದು ಒಂದು ಆಯಾಮದ ಒಂದಕ್ಕಿಂತ ಭಿನ್ನವಾಗಿರುವುದಿಲ್ಲ, ಇನ್ನೊಂದು ಜೋಡಿ ಚದರ ಆವರಣಗಳನ್ನು ಸೇರಿಸುತ್ತದೆ. ಮೊದಲ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ನಾವು ಸಾಲುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸಿದ್ದೇವೆ, ಎರಡನೆಯದರಲ್ಲಿ - ಕಾಲಮ್‌ಗಳ ಸಂಖ್ಯೆ.

ಅದರ ನಂತರ, ಎರಡು ಲೂಪ್‌ಗಳಲ್ಲಿ, ನಾವು ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು "" ಮೌಲ್ಯದೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುತ್ತೇವೆ - ಇದು ಕೇವಲ ವೈಟ್‌ಸ್ಪೇಸ್ ಅಕ್ಷರವಾಗಿದೆ. ಮೊದಲಿಗೆ, ಹೊರಗಿನ ಲೂಪ್ನಲ್ಲಿ, ನಾವು ಎಲ್ಲಾ ಸಾಲುಗಳ ಮೂಲಕ ಹೋಗುತ್ತೇವೆ. ಒಳಗಿನ ಲೂಪ್ನಲ್ಲಿ ಪ್ರತಿ ಸಾಲಿಗೆ, ನಾವು ಕಾಲಮ್ಗಳನ್ನು "ಟ್ರಾವರ್ಸ್" ಮಾಡುತ್ತೇವೆ.

ನಾನು ವಿವರವಾದ ಉದಾಹರಣೆಯನ್ನು ನೀಡುತ್ತೇನೆ: ಹೊರಗಿನ ಲೂಪ್‌ನ ಹಲವಾರು ಪುನರಾವರ್ತನೆಗಳ ನಂತರ, ಕೌಂಟರ್ i 9 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ. ಹೊರಗಿನ ಲೂಪ್‌ನ ದೇಹವು ಕಾರ್ಯಗತಗೊಳ್ಳಲು ಪ್ರಾರಂಭಿಸುತ್ತದೆ: ವೇರಿಯಬಲ್ j (ಒಳಗಿನ ಲೂಪ್‌ನ ಕೌಂಟರ್) ಅನ್ನು ಶೂನ್ಯಕ್ಕೆ ಪ್ರಾರಂಭಿಸಲಾಗುತ್ತದೆ, ಸ್ಥಿತಿಯನ್ನು ಪರಿಶೀಲಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಒಳಗಿನ ಲೂಪ್ನ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ: ನಕ್ಷೆ = "";, ಅಂದರೆ, ಹತ್ತನೇ ಸಾಲಿನ ಮೊದಲ ಅಕ್ಷರ (ಸೂಚ್ಯಂಕ ಶೂನ್ಯ) (ಕೌಂಟ್ಡೌನ್ ಶೂನ್ಯದಿಂದ ಎಂಬುದನ್ನು ಮರೆಯಬೇಡಿ) ಒಂದು ಜಾಗವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ನಂತರ, ಕೌಂಟರ್ j ಅನ್ನು 1 ನಿಗದಿಪಡಿಸಲಾಗಿದೆ, ಲೂಪ್‌ನ ದೇಹವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ... ಮತ್ತು ಕೌಂಟರ್ j 20 ಕ್ಕೆ ಸಮಾನವಾಗುವವರೆಗೆ - ಸ್ಥಿತಿಯನ್ನು ಪೂರೈಸಲಾಗಿಲ್ಲ ಮತ್ತು ಒಳಗಿನ ಲೂಪ್ ನಿರ್ಗಮಿಸುತ್ತದೆ. ನಂತರ ಬಾಹ್ಯ ಕೌಂಟರ್ ಅನ್ನು ಹೆಚ್ಚಿಸಲಾಗುತ್ತದೆ. ಈಗ ಅದು 10 ಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ ಮತ್ತು ಹೊರಗಿನ ಲೂಪ್ನ ದೇಹವನ್ನು ಮತ್ತೊಮ್ಮೆ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ ...

ಸ್ಥಳಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸಿದ ನಂತರ, ನಾವು ನಮ್ಮ ಆಟದ ಪಾತ್ರವನ್ನು ಮೊದಲ ಸಾಲಿನ ಮೊದಲ ಕಾಲಮ್ನಲ್ಲಿ ಇರಿಸುತ್ತೇವೆ.

ಮುಖ್ಯ ಲೂಪ್ನ ಆರಂಭದಲ್ಲಿ, ಹಿಂದಿನ ಔಟ್ಪುಟ್ನ ಪರದೆಯನ್ನು ತೆರವುಗೊಳಿಸಲು ನಾವು ಸಿಸ್ಟಮ್ () ಕಾರ್ಯವನ್ನು ಕರೆಯುತ್ತೇವೆ.

ನಂತರ ಪ್ರಾರಂಭದ ಚಕ್ರಗಳನ್ನು ಹೋಲುವ ಎರಡು ಚಕ್ರಗಳಿವೆ. ಪರದೆಯ ಮೇಲೆ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಲು ಅವುಗಳನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಮೊದಲ ಲೂಪ್ನ ದೇಹದ ಕೊನೆಯಲ್ಲಿ ಹೊಸ ಸಾಲಿನ ಅಕ್ಷರದ ಔಟ್ಪುಟ್ ಮಾತ್ರ ಗಮನಾರ್ಹ ವ್ಯತ್ಯಾಸವಾಗಿದೆ.

ಸರಿ, ನಂತರ ಒಂದು ಕವಲೊಡೆಯುವಿಕೆ ಇದೆ, ಅದರಲ್ಲಿ ಯಾವ ಕೀಲಿಯನ್ನು ಒತ್ತಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ. ಕವಲೊಡೆಯುವಿಕೆಯು ಕಳೆದ ಬಾರಿಯಿಂದ ಸ್ವಲ್ಪ ಬದಲಾಗಿದೆ, ಆದರೆ ಬ್ಲಾಕ್ಗಳ ವಿಷಯಗಳಲ್ಲಿ ವ್ಯತ್ಯಾಸಗಳಿವೆ: ಮೊದಲನೆಯದಾಗಿ, ವಸ್ತುವು ಇರುವ ನಿರ್ದೇಶಾಂಕಗಳಿಗೆ ನಾವು ಜಾಗವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ. ಅಂದರೆ, ನಾವು ಹಿಂದಿನ ಸ್ಥಳವನ್ನು ತೆರವುಗೊಳಿಸುತ್ತೇವೆ. ನಂತರ ನಾವು ನಿರ್ದೇಶಾಂಕಗಳಲ್ಲಿ ಒಂದನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ. ತದನಂತರ, ಹೊಸ ಸೂಚ್ಯಂಕಗಳೊಂದಿಗೆ ರಚನೆಯ ಅಂಶಕ್ಕೆ, ನಾವು "T" ಅಕ್ಷರವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.

"75" ಕೋಡ್‌ಗೆ ಉದಾಹರಣೆ - ಎಡಕ್ಕೆ ಚಲನೆ:

ಸಿ ++ ಕೋಡ್ಇಲ್ಲದಿದ್ದರೆ (ch == 75) (ನಕ್ಷೆ[x][y] = ""; y--; ನಕ್ಷೆ[x][y] = "T"; )

ಸರಿ, ಅದು ಮೂಲತಃ ಅಷ್ಟೆ. ಈ ಸಮಯದಲ್ಲಿ ನಾವು 15x20 ನಕ್ಷೆಯನ್ನು ಹೊಂದಿದ್ದೇವೆ, ಅದರಲ್ಲಿ ನೀವು ಅಕ್ಷರವನ್ನು ಸರಿಸಲು ಬಾಣಗಳನ್ನು ಬಳಸಬಹುದು - "ಟಿ" ಅಕ್ಷರ. ಆರನೇ ಪಾಠಕ್ಕೆ ಕೆಟ್ಟದ್ದಲ್ಲ! ಈ ಅಪ್ಲಿಕೇಶನ್ ನಮ್ಮ ಎಲ್ಲಾ ಕನ್ಸೋಲ್ ಪ್ರೋಗ್ರಾಂಗಳಿಗೆ ಆಧಾರವಾಗುತ್ತದೆ. ಯಾವುದೇ ಚಿತ್ರಾತ್ಮಕ ಸುಧಾರಣೆಗಳು ಇರುವುದಿಲ್ಲ. ನೀವು DOS ಕನ್ಸೋಲ್‌ನಿಂದ ಹೆಚ್ಚಿನದನ್ನು ಪಡೆಯಲು ಸಾಧ್ಯವಿಲ್ಲ ಮತ್ತು ನಾವು ವಿಂಡೋಸ್ ಕನ್ಸೋಲ್ ಅನ್ನು ಪರಿಗಣಿಸುವುದಿಲ್ಲ. ಇದು ಗಮನಾರ್ಹವಾಗಿ ಸಮಯ ಮತ್ತು ಶ್ರಮವನ್ನು ಉಳಿಸುತ್ತದೆ.

ನಾನು pseudo_game ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ವಿವರವಾಗಿ ಕಾಮೆಂಟ್ ಮಾಡಿದ್ದೇನೆ ಮತ್ತು ನೀವು ಅದನ್ನು ಕಷ್ಟವಿಲ್ಲದೆ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವಿರಿ. ಇಲ್ಲದಿದ್ದರೆ, ಪ್ರೋಗ್ರಾಂ ಪಟ್ಟಿಯನ್ನು ಮರು-ಓದಿರಿ ಮತ್ತು ನೀವು ಅದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವವರೆಗೆ ಈ ಸಮಸ್ಯೆಯನ್ನು ನೀವು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದಿಲ್ಲ :). ವಸ್ತುವನ್ನು ಕ್ರೋಢೀಕರಿಸಲು ವ್ಯಾಯಾಮಗಳು ನಿಮಗೆ ಸಹಾಯ ಮಾಡುತ್ತವೆ. ವ್ಯಾಯಾಮಗಳನ್ನು ಮಾಡುವುದು ಕಡ್ಡಾಯವಾಗಿದೆ. ಏನಾದರೂ ಅಸ್ಪಷ್ಟವಾಗಿದ್ದರೆ, ನನ್ನ ಇ-ಮೇಲ್‌ಗೆ ಬರೆಯಿರಿ - ನಾನು ಸಹಾಯ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತೇನೆ.

ವ್ಯಾಯಾಮಗಳು:

1. ಪ್ರೋಗ್ರಾಂನ ಸಂಪೂರ್ಣ ಪಟ್ಟಿಯಲ್ಲಿ, ನಾನು ಸ್ವಿಚ್ ಶಾಖೆಯನ್ನು ಬಳಸಿದ್ದೇನೆ. ಒಂದು ವೇಳೆ ಶಾಖೆಯ ಬ್ಲಾಕ್ ಅನ್ನು ಸಹ ಇಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ. ಬ್ಲಾಕ್‌ಗಳಾಗಿದ್ದರೆ ಉಳಿದವುಗಳನ್ನು ಸೇರಿಸಿ.

2. ಈಗ ಪ್ರೋಗ್ರಾಂ ಅಸ್ತಿತ್ವದಲ್ಲಿಲ್ಲದ ರಚನೆಯ ಅಂಶಗಳಿಗೆ ಬರೆಯಬಹುದು. ನಕ್ಷೆಯ ಮಿತಿಗಳನ್ನು ಬಿಡಲು ಪರಿಶೀಲಿಸಿ.

3. ಅಭ್ಯಾಸಕ್ಕಾಗಿ, ಪರದೆಯ ಮೇಲೆ ನೌಕಾ ಯುದ್ಧಕ್ಕಾಗಿ ಎರಡು ಕ್ಷೇತ್ರಗಳನ್ನು ಸೆಳೆಯುವ ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರಚಿಸಿ. ಮೊದಲನೆಯದು ಆಟಗಾರನಿಗೆ, ಎರಡನೆಯದು ಶತ್ರುಗಳಿಗೆ. ಎರಡನೆಯ ಕ್ಷೇತ್ರವು ಮೊದಲನೆಯ ಬಲಭಾಗದಲ್ಲಿರಬೇಕು.
ಅಂತರಗಳೊಂದಿಗೆ ಆಂತರಿಕ ಕೋಶಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ. ಗಡಿಯನ್ನು ಸೆಳೆಯಲು, ಮೈನಸ್ ಮತ್ತು ನೇರ ವಿಭಜಿಸುವ ರೇಖೆಯನ್ನು ಬಳಸಿ: -, |, ಮತ್ತು ಮೂಲೆಗಳಿಗೆ, ಹ್ಯಾಶ್ # ಅನ್ನು ಬಳಸಿ. ಪ್ರತಿ ಕ್ಷೇತ್ರದ ಎಡಭಾಗದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಸ್ಟಾಕ್ ಇದೆ; ಮೇಲೆ ಅಕ್ಷರಗಳಿವೆ.
ಸಂಪೂರ್ಣ ಕ್ಷೇತ್ರವನ್ನು ಪ್ರಾರಂಭಿಸಲು ನೀವು ಹಲವಾರು ಲೂಪ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಎರಡನೇ ಕ್ಷೇತ್ರದಲ್ಲಿ ಸಂಖ್ಯೆಗಳ ಕಾಲಮ್ ಅನ್ನು ತುಂಬಲು ಕೋಡ್ ಹೇಗಿರಬಹುದು ಎಂಬುದು ಇಲ್ಲಿದೆ:

ಸಿ ++ ಕೋಡ್ಇಂಟ್ ಸ್ಟ್ರಿಂಗ್; // ವೇರಿಯಬಲ್ ಸಾಲುಗಳನ್ನು ಇಂಟ್ ಕಾಲಮ್ ಅನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ; // ವೇರಿಯಬಲ್ ಕಾಲಮ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ ಚಾರ್ ನಕ್ಷೆ; ಕಾಲಮ್ = 15; ಫಾರ್ (ಸ್ಟ್ರಿಂಗ್ = 2; ಸ್ಟ್ರಿಂಗ್< 12; string++) { map = string - 1; }

C ಯಲ್ಲಿನ ಸರಣಿಗಳು ಯಾವುವು?

C ನಲ್ಲಿ ಅರೇಗಳನ್ನು ಹೇಗೆ ಘೋಷಿಸುವುದು?

C ನಲ್ಲಿ ಅರೇಗಳನ್ನು ಪ್ರಾರಂಭಿಸುವುದು ಹೇಗೆ?

ಡಮ್ಮೀಸ್‌ಗಾಗಿ ಸಿ ಯಲ್ಲಿ ಅರೇಗಳು.

ಸಿ ಯಲ್ಲಿನ ಅರೇಗಳು

C ಯಲ್ಲಿನ ರಚನೆಯು ಅದೇ ಪ್ರಕಾರದ ಅಂಶಗಳ ಸಂಗ್ರಹವಾಗಿದ್ದು ಅದನ್ನು ಸೂಚ್ಯಂಕದಿಂದ ಪ್ರವೇಶಿಸಬಹುದು. C ಯಲ್ಲಿನ ಅರೇಗಳ ಅಂಶಗಳು ಕಂಪ್ಯೂಟರ್ನ ಮೆಮೊರಿಯಲ್ಲಿ ಒಂದರ ನಂತರ ಒಂದರಂತೆ ನೆಲೆಗೊಂಡಿವೆ.

C ಯಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವ ಮತ್ತು ಭರ್ತಿ ಮಾಡುವ ಸರಳ ಉದಾಹರಣೆ:

// @author Subbotin B.P..h> ಅನೂರ್ಜಿತ ಮುಖ್ಯ(ಶೂನ್ಯ) ( int nArr; nArr = 1; nArr = 2; nArr = 3; printf("\n\tArray\n\n"); printf("nArr\t =\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); printf("nArr\t=\t%d\n", nArr); 0 ಹಿಂತಿರುಗಿ ;)

ನಾವು ಪಡೆಯುತ್ತೇವೆ:

ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು int ಪ್ರಕಾರದ ಅಂಶಗಳನ್ನು ಹೊಂದಿರುವ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುತ್ತೇವೆ:

ಇಲ್ಲಿ ರಚನೆಯ ಹೆಸರು nArr ಆಗಿದೆ, ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ ಮೂರು, ಅರೇ ಎಲಿಮೆಂಟ್ ಪ್ರಕಾರವು ಇಂಟ್ ಆಗಿದೆ.

ಒಂದು ಶ್ರೇಣಿಯು ಅಂಶಗಳ ಸಂಗ್ರಹವಾಗಿದೆ. ರಚನೆಯ ಪ್ರತಿಯೊಂದು ಅಂಶವನ್ನು ಅದರ ಸಂಖ್ಯೆಯಿಂದ ಉಲ್ಲೇಖಿಸಬಹುದು. ಸಂಖ್ಯೆಯನ್ನು ಸಾಮಾನ್ಯವಾಗಿ ಸೂಚ್ಯಂಕ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ರಚನೆಯ ಅಂಶಗಳು ಶೂನ್ಯದಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತವೆ. ರಚನೆಯ ಮೊದಲ ಅಂಶಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸೋಣ ಮತ್ತು ಮೊದಲ ಅಂಶವು ಸೂಚ್ಯಂಕ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ:

ರಚನೆಯ ಎರಡನೇ ಅಂಶಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸೋಣ ಮತ್ತು ಎರಡನೇ ಅಂಶವು ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದೆ:

ರಚನೆಯ ಮೂರನೇ ಅಂಶಕ್ಕೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸೋಣ ಮತ್ತು ಮೂರನೇ ಅಂಶವು ಸೂಚ್ಯಂಕ ಎರಡು ಹೊಂದಿದೆ:

ನಾವು ಪರದೆಯ ಮೇಲೆ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಿದಾಗ, ನಾವು ಅವುಗಳ ಮೌಲ್ಯಗಳನ್ನು ಪಡೆಯುತ್ತೇವೆ. ಈ ರೀತಿ:

printf("nArr\t=\t%d\n", nArr);

ರಚನೆಯ ಅಂಶವನ್ನು ಪಡೆಯಲು, ನೀವು ರಚನೆಯ ಹೆಸರು ಮತ್ತು ಅಂಶದ ಸೂಚಿಯನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು:

ಇದು ರಚನೆಯ ಮೊದಲ ಅಂಶವಾಗಿದೆ, ಏಕೆಂದರೆ ಮೊದಲ ಅಂಶವು ಸೂಚ್ಯಂಕ ಶೂನ್ಯವನ್ನು ಹೊಂದಿದೆ.

ರಚನೆಯ ಮೂರನೇ ಅಂಶದ ಮೌಲ್ಯವನ್ನು ಇಂಟ್ a ವೇರಿಯೇಬಲ್‌ಗೆ ನಿಯೋಜಿಸೋಣ:

ಸರಣಿಯ ಮೂರನೇ ಅಂಶದ ಸೂಚ್ಯಂಕವು ಎರಡಕ್ಕೆ ಸಮಾನವಾಗಿರುತ್ತದೆ, ಏಕೆಂದರೆ ಸೂಚ್ಯಂಕಗಳನ್ನು ಶೂನ್ಯದಿಂದ ಎಣಿಸಲಾಗುತ್ತದೆ.

ಈಗ C ನಲ್ಲಿ ಸರಣಿಗಳನ್ನು ಘೋಷಿಸುವ ಸಾಮಾನ್ಯ ನಿಯಮ: ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವಾಗ, ನೀವು ಅದರ ಹೆಸರು, ಅಂಶಗಳ ಪ್ರಕಾರ ಮತ್ತು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸಬೇಕು. ಅಂಶಗಳ ಸಂಖ್ಯೆ ನೈಸರ್ಗಿಕ ಸಂಖ್ಯೆ, ಅಂದರೆ. ಇಡೀ ಧನಾತ್ಮಕವಾಗಿದೆ. ಶೂನ್ಯವು ಅಂಶಗಳ ಸಂಖ್ಯೆಯಾಗಿರಬಾರದು. ಅರೇ ಅಂಶಗಳ ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಸಿ ಯಲ್ಲಿ ಅರೇ ಘೋಷಣೆಗಳ ಉದಾಹರಣೆಗಳು ಇಲ್ಲಿವೆ:

ಇಂಟ್ ನಾರ್; // ನೂರು ಪೂರ್ಣಾಂಕಗಳನ್ನು ಹಿಡಿದಿಡಲು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಗಿದೆ;
ಫ್ಲೋಟ್ ಫರ್; // 5 ಫ್ಲೋಟ್ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಗಿದೆ;
ಚಾರ್ ಕಾರ್ರ್; // ಎರಡು ಅಕ್ಷರಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲಾಗಿದೆ;

ವೇರಿಯಬಲ್ ಸಂಖ್ಯೆಯ ಅಂಶಗಳೊಂದಿಗೆ ಸರಣಿಯನ್ನು ಘೋಷಿಸುವುದು ತಪ್ಪಾಗುತ್ತದೆ:

ಇಂಟ್ varElem;
ಇಂಟ್ ನಾರ್; // ದೋಷ! ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ವೇರಿಯೇಬಲ್‌ಗೆ ಹೊಂದಿಸಲಾಗುವುದಿಲ್ಲ;

ಆದರೆ ನೀವು ಸ್ಥಿರ ಮೌಲ್ಯದೊಂದಿಗೆ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹೊಂದಿಸಬಹುದು: ನೇರ ಧನಾತ್ಮಕ ಪೂರ್ಣಾಂಕ 1, 2, 3... ಅಥವಾ ಸ್ಥಿರ:

ಕಾನ್ಸ್ಟ್ ಇಂಟ್ ಅರೇ ಉದ್ದ = 3;
ಇಂಟ್ ನಾರ್;

C ನಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವಾಗ, ನೀವು ತಕ್ಷಣ ಅದನ್ನು ಪ್ರಾರಂಭಿಸಬಹುದು:

ಇಂಟ್ nMassiv = (1, 2, 3);

ಎಲ್ಲಾ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರಾರಂಭಿಸಿದರೆ ನೀವು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿನ ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಬಿಟ್ಟುಬಿಡಬಹುದು:

ಇಂಟ್ nMassiv = (1, 2, 3);

ಈ ಸಂದರ್ಭದಲ್ಲಿ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ಧರಿಸಲಾಗುತ್ತದೆ.

ರಚನೆಯನ್ನು ಘೋಷಿಸುವಾಗ ಅದರ ಅಂಶಗಳ ಭಾಗವನ್ನು ಮಾತ್ರ ನೀವು ವ್ಯಾಖ್ಯಾನಿಸಬಹುದು:

ಇಂಟ್ nMassiv = (1, 2);

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ರಚನೆಯ ಮೊದಲ ಎರಡು ಅಂಶಗಳನ್ನು ಪ್ರಾರಂಭಿಸಲಾಗಿದೆ, ಆದರೆ ಮೂರನೆಯದನ್ನು ವಿವರಿಸಲಾಗಿಲ್ಲ.

ಅಕ್ಷರ ರಚನೆಯ ಉದಾಹರಣೆ:

ಚಾರ್ cArr = ("S", "B", "P");

ರಚನೆಯನ್ನು ಘೋಷಿಸುವಾಗ, ವೇರಿಯಬಲ್‌ನ ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸಲಾಗುವುದಿಲ್ಲ. ಆದರೆ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವಾಗ ನೀವು ಅಸ್ಥಿರಗಳನ್ನು ಬಳಸಬಹುದು:

ಇಂಟ್ ಇಂಡಿ = 0;
ಚಾರ್ ಸಿಆರ್ = cArr;

ಲೂಪ್ಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುವಾಗ ಇದನ್ನು ಬಳಸಲಾಗುತ್ತದೆ. ಉದಾಹರಣೆ:

// @author Subbotin B.P..h> ಅನೂರ್ಜಿತ ಮುಖ್ಯ(ಶೂನ್ಯ) ( const int arrayLength = 3; int nArr; for(int inn = 0; inn< 3; inn++) { nArr = inn + 1; } printf("\n\tArray\n\n"); for(int inn = 0; inn < 3; inn++) { printf("nArr[%d]\t=\t%d\n", inn, nArr); } return 0; }

ಉದಾಹರಣೆಯಲ್ಲಿ, ಮೊದಲ ಲೂಪ್ನಲ್ಲಿ ನಾವು ಟೈಪ್ ಇಂಟ್ನ ಅಂಶಗಳೊಂದಿಗೆ ಶ್ರೇಣಿಯನ್ನು ತುಂಬುತ್ತೇವೆ ಮತ್ತು ಎರಡನೇ ಲೂಪ್ನಲ್ಲಿ ನಾವು ಈ ಅಂಶಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ.

C ನಲ್ಲಿ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವುದು
ಅರೇ ಒಂದು ದ್ವಿತೀಯ ಡೇಟಾ ಪ್ರಕಾರವಾಗಿದೆ. C ಯಲ್ಲಿನ ರಚನೆಯು ನಿರ್ದಿಷ್ಟ ಪ್ರಕಾರದ ಸ್ಪಷ್ಟ ಗಾತ್ರದ ಅಂಶಗಳ ಸಂಗ್ರಹವಾಗಿದೆ. ಅಂದರೆ, ರೂಬಿಯಲ್ಲಿನ ಅರೇಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಸಿ ಯಲ್ಲಿನ ಅರೇಗಳು ಒಂದೇ ರೀತಿಯದ್ದಾಗಿರುತ್ತವೆ (ಅವು ಕೇವಲ ಒಂದು ಪ್ರಕಾರದ ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತವೆ) ಮತ್ತು ಪೂರ್ವನಿರ್ಧರಿತ ಉದ್ದವನ್ನು (ಗಾತ್ರ) ಹೊಂದಿರುತ್ತವೆ.

C ನಲ್ಲಿ, ಅರೇಗಳನ್ನು ಸ್ಥೂಲವಾಗಿ 2 ವಿಧಗಳಾಗಿ ವಿಂಗಡಿಸಬಹುದು: ಸಂಖ್ಯೆಗಳ ಒಂದು ಶ್ರೇಣಿ ಮತ್ತು ಅಕ್ಷರಗಳ ಒಂದು ಶ್ರೇಣಿ. ಸಹಜವಾಗಿ, ಅಂತಹ ವಿಭಾಗವು ಸಂಪೂರ್ಣವಾಗಿ ಅನಿಯಂತ್ರಿತವಾಗಿದೆ ಏಕೆಂದರೆ ಚಿಹ್ನೆಗಳು ಸಹ ಪೂರ್ಣಾಂಕಗಳಾಗಿವೆ. ಅಕ್ಷರ ರಚನೆಗಳು ಸ್ವಲ್ಪ ವಿಭಿನ್ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಸಹ ಹೊಂದಿವೆ. ರಚನೆಯ ಘೋಷಣೆಗಳ ಉದಾಹರಣೆಗಳನ್ನು ಕೆಳಗೆ ನೀಡಲಾಗಿದೆ:

ಇಂಟ್ ಅರ್; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); ಚಾರ್ ch = ("R","u","b","y","D","e","v",".","r","u"); ಚಾರ್ ch2 = "ಸೈಟ್";

ಮೊದಲ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಗಾತ್ರ 100 ಅಂಶಗಳ ಪೂರ್ಣಾಂಕಗಳ ಒಂದು ಶ್ರೇಣಿಯನ್ನು (ಪ್ರತಿ ಸಂಖ್ಯೆಗೆ 4 ಬೈಟ್‌ಗಳು) ಘೋಷಿಸುತ್ತೇವೆ. ಹೆಚ್ಚು ನಿಖರವಾಗಿ, ನಾವು ಇಂಟ್ ಪ್ರಕಾರದ 100 ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತೇವೆ.

ಎರಡನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು 10 ಪೂರ್ಣಾಂಕ ಅಂಶಗಳ ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಮತ್ತು ರಚನೆಯ ಅಂಶಗಳಿಗೆ ತಕ್ಷಣವೇ ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ.

ಮೂರನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ. C ನಲ್ಲಿ ಯಾವುದೇ ತಂತಿಗಳಿಲ್ಲ, ಆದರೆ ತಂತಿಗಳನ್ನು ಬದಲಿಸುವ ಅಕ್ಷರ ಸರಣಿಗಳಿವೆ.

ನಂತರದ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ವಿಶೇಷವಾದ, ಹೆಚ್ಚು ಸಂಕ್ಷಿಪ್ತ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ಅಕ್ಷರಗಳ ಶ್ರೇಣಿಯನ್ನು ಸಹ ಘೋಷಿಸುತ್ತೇವೆ. ಅರೇಗಳು ch ಮತ್ತು ch2 ಬಹುತೇಕ ಒಂದೇ ಆಗಿರುತ್ತವೆ, ಆದರೆ ಒಂದು ವ್ಯತ್ಯಾಸವಿದೆ. ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಲು ನಾವು ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸಿದಾಗ, ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಅರೇ ಡಿಕ್ಲರೇಶನ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಬಳಸುವಾಗ ಅಕ್ಷರ ರಚನೆಯ ಅಂತ್ಯಕ್ಕೆ \0 ಅಕ್ಷರವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ, ನಾವೇ \0 ಅನ್ನು ಅಕ್ಷರ ರಚನೆಯ ಕೊನೆಯ ಅಂಶವಾಗಿ ಸೇರಿಸಬೇಕು. \0 (ಶೂನ್ಯ) ಅಕ್ಷರವನ್ನು ಒಂದು ಸಾಲಿನ ಅಂತ್ಯವನ್ನು ಗುರುತಿಸಲು ಬಳಸಲಾಗುತ್ತದೆ. ಪ್ರತ್ಯೇಕ ಲೇಖನದಲ್ಲಿ ನಾವು ಸ್ಟ್ರೇಕ್ಗಳ ಬಗ್ಗೆ ಹೆಚ್ಚು ವಿವರವಾಗಿ ಮಾತನಾಡುತ್ತೇವೆ.

C ನಲ್ಲಿ ಅರೇ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸಲಾಗುತ್ತಿದೆ

C ಯಲ್ಲಿ, ರಚನೆಯ ಅಂಶಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು ತುಂಬಾ ಕ್ಷುಲ್ಲಕವಾಗಿದೆ ಮತ್ತು ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಲ್ಲಿ ಇದನ್ನು ಹೇಗೆ ಮಾಡಲಾಗುತ್ತದೆ ಎಂಬುದನ್ನು ಹೋಲುತ್ತದೆ. ರಚನೆಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ವೇರಿಯೇಬಲ್ ಹೆಸರಿನ ನಂತರ, ನಾವು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಅಂಶದ ಸೂಚಿಯನ್ನು (ಕೀ ಎಂದೂ ಕರೆಯಲಾಗುತ್ತದೆ) ಸೂಚಿಸುತ್ತೇವೆ. ಕೆಳಗಿನ ಉದಾಹರಣೆಯು ನಾವು ರಚನೆಯ ಮೊದಲ ಅಂಶವನ್ನು ಹೇಗೆ ಪ್ರವೇಶಿಸುತ್ತೇವೆ ಎಂಬುದನ್ನು ತೋರಿಸುತ್ತದೆ:

#ಸೇರಿಸು int main() (int arr; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); char ch = ("R","u","b"," y","D","e","v",".","r","u") ; char ch2 = "site"; printf("%d\n", arr); printf(" %c\n", ch); )

ಕೋಡ್ printf("%d\n", a);

2 ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ, 1 ಅಲ್ಲ, ಏಕೆಂದರೆ ಸರಣಿಗಳ ಇಂಡೆಕ್ಸಿಂಗ್ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ ಮತ್ತು ಇದರ ಇನ್ನೊಂದು ದೃಢೀಕರಣ ಸಾಲು printf("%c\n", ch); , ಇದು "R" ಅಕ್ಷರವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ - ಅರೇ ch ನ ಶೂನ್ಯ ಅಂಶ.

ಸಾಮಾನ್ಯವಾಗಿ, ರಚನೆಯ ಘೋಷಣೆಯು ಈ ಕೆಳಗಿನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಹೊಂದಿದೆ:<количество_элементов>] = <список, элементов, массива>

ಡೇಟಾ_ಟೈಪ್ ವೇರಿಯಬಲ್_ಹೆಸರು[

ರಚನೆಯ ಅಂಶಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಅಂಶಗಳ ಪಟ್ಟಿಯು ರಚನೆಯ ಘೋಷಣೆಯ ಅಗತ್ಯ ಗುಣಲಕ್ಷಣಗಳಾಗಿವೆ, ಅವುಗಳಲ್ಲಿ ಯಾವುದಾದರೂ ಒಂದು ಅಗತ್ಯವಿದೆ, ಆದರೆ ಎರಡೂ ಏಕಕಾಲದಲ್ಲಿ ಅಲ್ಲ.

ಅರೇಗಳ ರಚನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು, ಸಿ ಯಲ್ಲಿನ ಪಾಯಿಂಟರ್‌ಗಳ ಪರಿಕಲ್ಪನೆಯೊಂದಿಗೆ ನೀವು ಪರಿಚಿತರಾಗಿರಬೇಕು.
ಡೇಟಾವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿರ್ದಿಷ್ಟ ಗಾತ್ರದ ಮೆಮೊರಿಯ ತುಣುಕನ್ನು ನಿಯೋಜಿಸಲು ಮತ್ತು ಅದು ಯಾವ ರೀತಿಯ ಡೇಟಾ ಎಂದು ನಿರ್ಧರಿಸಲು ಡೇಟಾ ಪ್ರಕಾರಗಳು ಅಗತ್ಯವಾಗಿವೆ ಏಕೆಂದರೆ ಸ್ಪಷ್ಟವಾದ ವ್ಯಾಖ್ಯಾನವಿಲ್ಲದೆ ಸೊನ್ನೆಗಳು ಮತ್ತು ಬಿಡಿಗಳ ಸೆಟ್ ಸಂಖ್ಯೆಯೇ ಎಂಬುದು ಸ್ಪಷ್ಟವಾಗಿಲ್ಲ, ಒಂದು ಚಿಹ್ನೆ, ಅಥವಾ ಇನ್ನೇನಾದರೂ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ವೇರಿಯೇಬಲ್ ಒಂದು ನಿರ್ದಿಷ್ಟ ಗಾತ್ರ ಮತ್ತು ಪ್ರಕಾರದ ಮೆಮೊರಿಯ ತುಣುಕುಗೆ ಉಲ್ಲೇಖವಾಗಿದೆ, ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ವೇರಿಯೇಬಲ್ ನಿರ್ದಿಷ್ಟ 4-ಬೈಟ್ ಮೆಮೊರಿ ಪ್ರದೇಶವನ್ನು ಸೂಚಿಸುತ್ತದೆ, ಇದರಲ್ಲಿ ಪೂರ್ಣಾಂಕವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಚಾರ್ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಸೂಚಿಸುತ್ತದೆ 1-ಬೈಟ್ ಮೆಮೊರಿ ಪ್ರದೇಶ, ಇದರಲ್ಲಿ ಅಕ್ಷರವನ್ನು ಸಂಗ್ರಹಿಸಲಾಗಿದೆ (ಕ್ಯಾರೆಕ್ಟರ್ ಕೋಡ್ ).

ವೇರಿಯೇಬಲ್ ಸೂಚಿಸುವ ವಿಳಾಸವನ್ನು ಪಡೆಯಲು, ನಾವು ವಿಶೇಷ ಆಪರೇಟರ್ ಮತ್ತು - ವಿಳಾಸ ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸುತ್ತೇವೆ, ಉದಾಹರಣೆಗೆ:

#ಸೇರಿಸು int main() (int arr; int a = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10); char ch = ("R","u","b"," y","D","e","v",".","r","u") ; char ch2 = "site"; int num = 100500; printf("%p\n", &arr ;)

ಲೈನ್ printf("%p\n", &arr);

0xbfbbe068 ಅನ್ನು ಮುದ್ರಿಸುತ್ತದೆ. 0xbfbbe068 ಎಂಬುದು 100500 ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸಲಾದ ಮೆಮೊರಿ ವಿಳಾಸದ ಹೆಕ್ಸಾಡೆಸಿಮಲ್ ಪ್ರಾತಿನಿಧ್ಯವಾಗಿದೆ.

#ಸೇರಿಸು ಪಾಯಿಂಟರ್‌ಗಳು ವಿಶೇಷ ರೀತಿಯ ವೇರಿಯಬಲ್‌ಗಳಾಗಿವೆ, ಅದು ಸಾಮಾನ್ಯ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ, ಆದರೆ ಅವುಗಳ ವಿಳಾಸಗಳನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹಿಸುತ್ತದೆ.

int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )
$./ಪ್ರೋಗ್ರಾಂ
ಎ: 0xbfe32008

ಬಿ: 0xbfe3200c

#ಸೇರಿಸು ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು a ಮತ್ತು b ಅನ್ನು ಒಂದೇ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ - ಸಂಖ್ಯೆ 10, ಆದರೆ ವೇರಿಯೇಬಲ್‌ಗಳು a ಮತ್ತು b ಮೆಮೊರಿಯ ಎರಡು ವಿಭಿನ್ನ ಕ್ಷೇತ್ರಗಳನ್ನು ಉಲ್ಲೇಖಿಸುತ್ತವೆ, ಅಂದರೆ, ನಾವು 10 ಅನ್ನು ಮೆಮೊರಿಯಲ್ಲಿ ಎರಡು ಬಾರಿ ಸಂಗ್ರಹಿಸುತ್ತೇವೆ. ನಾವು ವೇರಿಯೇಬಲ್ b ನ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಿದರೆ, ಅದು ವೇರಿಯೇಬಲ್ a ಮೇಲೆ ಪರಿಣಾಮ ಬೀರುವುದಿಲ್ಲ ಮತ್ತು ಪ್ರತಿಯಾಗಿ. ರೂಬಿಯಲ್ಲಿನ ವೇರಿಯೇಬಲ್‌ಗಳೊಂದಿಗೆ ನಾವು ಕೆಲಸ ಮಾಡುವ ವಿಧಾನಕ್ಕಿಂತ ಇದು ವಿಭಿನ್ನವಾಗಿದೆ, ಅಲ್ಲಿ ಅಸ್ಥಿರಗಳು ಮೆಮೊರಿಯಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ವಸ್ತುಗಳಿಗೆ ಉಲ್ಲೇಖಗಳಾಗಿವೆ ಮತ್ತು a = b = 10 ಶೈಲಿಯಲ್ಲಿ ನಿಯೋಜಿಸುವಾಗ, ನಾವು ಒಂದು ವಸ್ತುವನ್ನು ಪಡೆಯುತ್ತೇವೆ - ಸಂಖ್ಯೆ 10 ಮತ್ತು ಅದರ ಎರಡು ಉಲ್ಲೇಖಗಳು.

int main() ( int a = 10; int * b = printf("A:\n\taddress: %p\n\tvalue: %d\n",&a, a); printf("B:\n\ taddress: %p\n\tvalue: %d\n",b, *b); )

int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )
ಮರಣದಂಡನೆಯ ಫಲಿತಾಂಶ:
ಉ:
ವಿಳಾಸ: 0xbfed0fa8
ಮೌಲ್ಯ: 10
ಉ:
ವಿಳಾಸ: 0xbfed0fa8

ಬಿ:

ಪಾಯಿಂಟರ್‌ಗಳು ಮತ್ತು ಅರೇಗಳು

#ಸೇರಿಸು ವಾಸ್ತವವಾಗಿ, ಅನೇಕ ಜನರು ತಿಳಿದಿರುವ ಅರ್ಥದಲ್ಲಿ ಸಿ ಸರಣಿಗಳನ್ನು ಹೊಂದಿಲ್ಲ. C ಯಲ್ಲಿನ ಯಾವುದೇ ರಚನೆಯು ರಚನೆಯ ಶೂನ್ಯ ಅಂಶಕ್ಕೆ ಸರಳವಾಗಿ ಉಲ್ಲೇಖವಾಗಿದೆ. ಉದಾಹರಣೆ:

int main() ( int a = (10,20,30); printf("a-Address:%p\n", &a); printf("a-Address:%p\n", &a); printf( "a-Value:%d\n", a printf("a-Size:%d\n", sizeof(a));

int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )
ಫಲಿತಾಂಶ:
ಫಲಿತಾಂಶ:
a-ವಿಳಾಸ:0xbfc029b4
a-ಮೌಲ್ಯ:10

ನೀವು ನೋಡುವಂತೆ, ನಾನು ನಿಮ್ಮನ್ನು ಮೋಸಗೊಳಿಸಲಿಲ್ಲ, ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಉಲ್ಲೇಖಿಸುವ ವೇರಿಯಬಲ್ ವಾಸ್ತವವಾಗಿ ಅದರ ಶೂನ್ಯ ಅಂಶವನ್ನು ಮಾತ್ರ ಸೂಚಿಸುತ್ತದೆ, ಅಂದರೆ, ಇದು ಮೊದಲ ಅಂಶದ ಶೇಖರಣಾ ವಿಳಾಸಕ್ಕೆ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.

ನಾವು ಪ್ರೋಗ್ರಾಂ ಅನ್ನು ರನ್ ಮಾಡಿದಾಗ, ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಮ್ ಪ್ರೋಗ್ರಾಂಗೆ ಎರಡು ವಿಶೇಷ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ಒದಗಿಸುತ್ತದೆ - ಸ್ಟಾಕ್ ಮತ್ತು ಹೀಪ್. ನಮ್ಮ ಪ್ರೋಗ್ರಾಂ ಸ್ಟಾಕ್ ಅನ್ನು ಮಾತ್ರ ಬಳಸುತ್ತದೆ. ಒಂದು ಸ್ಟಾಕ್ ಆದೇಶದ ರೀತಿಯಲ್ಲಿ ಮೌಲ್ಯಗಳನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸಿದಾಗ, ನಾವು ಅಂಶಗಳ ಸಂಗ್ರಹದ ಶೂನ್ಯ ಅಂಶಕ್ಕೆ ಪಾಯಿಂಟರ್ ಅನ್ನು ರಚಿಸುತ್ತೇವೆ ಮತ್ತು N ಸಂಖ್ಯೆಯ ಅಂಶಗಳಿಗೆ ಮೆಮೊರಿಯನ್ನು ಕಾಯ್ದಿರಿಸುತ್ತೇವೆ. ಮೇಲಿನ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಟೈಪ್ ಇಂಟ್‌ನ 3 ಅಂಶಗಳ ಸಂಗ್ರಹವನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅಂದರೆ. ಪ್ರತಿಯೊಂದು ಅಂಶವು 4 ಬೈಟ್‌ಗಳ ಮೆಮೊರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ. ನಾವು sizeof() ಕಾರ್ಯವನ್ನು ಬಳಸಿದಾಗ, ಅದಕ್ಕೆ ರವಾನೆಯಾದ ಆರ್ಗ್ಯುಮೆಂಟ್‌ನ ಬೈಟ್‌ಗಳಲ್ಲಿ ಗಾತ್ರವನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ, ನಾವು ಮೌಲ್ಯವನ್ನು ಪಡೆದುಕೊಂಡಿದ್ದೇವೆ 12 ಅಂದರೆ. ರಚನೆಯು 12 ಬೈಟ್‌ಗಳ ಮೆಮೊರಿಯನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ: 3 ಅಂಶಗಳು * 4 ಬೈಟ್‌ಗಳು. ಸಂಗ್ರಹದ ಅಂಶಗಳನ್ನು ಸಂಗ್ರಹಿಸಲು ಸ್ಟಾಕ್ ಅನ್ನು ಬಳಸುವುದರಿಂದ, ಅಂಶಗಳನ್ನು ಕ್ರಮವಾಗಿ ಸಂಗ್ರಹಿಸಲಾಗುತ್ತದೆ, ಅಂದರೆ, ಅವು ಸ್ಟಾಕ್‌ನ ಪಕ್ಕದ ಪ್ರದೇಶಗಳನ್ನು ಆಕ್ರಮಿಸುತ್ತವೆ, ಇದರರ್ಥ ನಾವು ಅಂಶದ ಸ್ಥಾನ ಮತ್ತು ಗಾತ್ರವನ್ನು ತಿಳಿದುಕೊಳ್ಳುವ ಮೂಲಕ ಸಂಗ್ರಹಣೆಯ ಮೂಲಕ ನ್ಯಾವಿಗೇಟ್ ಮಾಡಬಹುದು. ಸಂಗ್ರಹ. ಉದಾಹರಣೆ:

#ಸೇರಿಸು int main() ( int a = (10,20,30,40,10), i; for(i = 0; i<= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, a[i], &a[i]); }

int main() ( int a = (10,20,30); printf("a-Address:%p\n", &a); printf("a-Address:%p\n", &a); printf( "a-Value:%d\n", a printf("a-Size:%d\n", sizeof(a));

int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )
a 0xbfbeda88 ರಲ್ಲಿ 10 ಅನ್ನು ಹೊಂದಿದೆ
a 0xbfbeda8c ನಲ್ಲಿ 20 ಅನ್ನು ಹೊಂದಿದೆ
a 0xbfbeda90 ರಲ್ಲಿ 30 ಅನ್ನು ಹೊಂದಿದೆ
a 0xbfbeda94 ರಲ್ಲಿ 40 ಅನ್ನು ಹೊಂದಿದೆ
a 0xbfbeda98 ರಲ್ಲಿ 10 ಅನ್ನು ಹೊಂದಿದೆ
a 5 ರಲ್ಲಿ 0xbfbeda9c ಹೊಂದಿದೆ

ಪ್ರೋಗ್ರಾಂ ನಮಗೆ 5 ಅಂಶಗಳ ರಚನೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಮುದ್ರಿಸಿದೆ: ಅಂಶ ಸಂಖ್ಯೆ, ಮೌಲ್ಯ ಮತ್ತು ಮೆಮೊರಿ ವಿಳಾಸ. ಅಂಶಗಳ ವಿಳಾಸಗಳಿಗೆ ಗಮನ ಕೊಡಿ - ನಾನು ನಿಮಗೆ ಹೇಳಿದ್ದು ಇದನ್ನೇ. ವಿಳಾಸಗಳು ಸಾಲಿನಲ್ಲಿವೆ ಮತ್ತು ಪ್ರತಿ ಮುಂದಿನವು ಹಿಂದಿನದಕ್ಕಿಂತ 4 ರಿಂದ ದೊಡ್ಡದಾಗಿದೆ. ಸಂಗ್ರಹಣೆಯ 5 ನೇ ಅಂಶವು, ನಾವು ನಿಜವಾಗಿ ಘೋಷಿಸಲಿಲ್ಲ, ಸಂಗ್ರಹಣೆಯ ಒಟ್ಟು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ. ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ಸಂಗತಿಯೆಂದರೆ, ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ದಾಟಲು ಪಾಯಿಂಟರ್‌ಗಳನ್ನು ಬಳಸಬಹುದು. ಉದಾಹರಣೆ:

#ಸೇರಿಸು int main() ( int a = (10,20,30,40,10), i; int * b = a; for(i = 0; i<= sizeof(a)/sizeof(int); i++) printf("a[%d] has %d in %p\n", i, *(b + i), b + i); }

ಟಿಪ್ಪಣಿಗಳು

1. ನಾವು ಪಾಯಿಂಟರ್ ಬಿ ಅನ್ನು ಅರೇ a ಯ ವಿಳಾಸವಲ್ಲ, ಆದರೆ ವೇರಿಯೇಬಲ್ a ನ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತೇವೆ, ಏಕೆಂದರೆ a ವಾಸ್ತವವಾಗಿ ಪಾಯಿಂಟರ್ ಆಗಿದೆ.

2. ರಚನೆಯ ಅಂಶಗಳ ಸೂಚ್ಯಂಕಗಳನ್ನು ಸೂಚಿಸುವ ಚದರ ಆವರಣಗಳ ಬಳಕೆಯು ಸಂಗ್ರಹಣಾ ಅಂಶಗಳಿಗೆ ಹೆಚ್ಚು ಅನುಕೂಲಕರ ಮತ್ತು ಅರ್ಥವಾಗುವ ಪ್ರವೇಶಕ್ಕಾಗಿ ಸಿ ಯಲ್ಲಿ ಸಿಂಟ್ಯಾಕ್ಟಿಕ್ ಸಕ್ಕರೆಯಾಗಿದೆ.

3. ನಾನು ಈಗಾಗಲೇ ಹೇಳಿದಂತೆ, C ನಲ್ಲಿ ಯಾವುದೇ ಸಾಂಪ್ರದಾಯಿಕ ಸರಣಿಗಳಿಲ್ಲ, ಆದ್ದರಿಂದ C ಯ ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಒತ್ತಿಹೇಳಲು ನಾನು ಅವುಗಳನ್ನು ಸಂಗ್ರಹಣೆಗಳು ಎಂದು ಕರೆಯುತ್ತೇನೆ.

4. ರಚನೆಯ ಅಂಶದ ವಿಳಾಸ 1 ಈ ಪ್ರಕಾರದ ಅಂಶವನ್ನು ಸಂಗ್ರಹಿಸಲು ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಪ್ರಮಾಣದಿಂದ ರಚನೆಯ ಅಂಶದ ವಿಳಾಸ 0 ಗಿಂತ ಹೆಚ್ಚಾಗಿರುತ್ತದೆ. ನಾವು ಟೈಪ್ ಇಂಟ್ ಅಂಶಗಳೊಂದಿಗೆ ಕೆಲಸ ಮಾಡುತ್ತೇವೆ, ಪ್ರತಿಯೊಂದೂ ಸಂಗ್ರಹಿಸಲು 4 ಬೈಟ್‌ಗಳನ್ನು ಬಳಸುತ್ತದೆ. ಮೆಮೊರಿಯಲ್ಲಿನ ರಚನೆಯ ಅಂಶದ ವಿಳಾಸ ಮತ್ತು ಸಾಮಾನ್ಯವಾಗಿ ಯಾವುದೇ ಡೇಟಾದ ವಿಳಾಸವು ಅದರ ಸಂಗ್ರಹಣೆಗಾಗಿ ನಿಯೋಜಿಸಲಾದ ಮೆಮೊರಿಯ ಮೊದಲ ಬೈಟ್‌ನ ವಿಳಾಸವಾಗಿದೆ.

5. ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಸುಲಭವಾಗುವಂತೆ, ಕಂಪ್ಯೂಟರ್‌ನ ಮೆಮೊರಿಯು ಒಂದು ದೊಡ್ಡ ಚಿತ್ರಮಂದಿರವಾಗಿದೆ ಎಂದು ಊಹಿಸಿ, ಅಲ್ಲಿ ಆಸನಗಳನ್ನು 0 ರಿಂದ 1_073_741_824 ಎಂದು ಹೇಳೋಣ. ಚಾರ್ ಪ್ರಕಾರದ ಡೇಟಾವು ಸಾಮಾನ್ಯ ಗಾತ್ರದ ಬಟ್ ಅನ್ನು ಹೊಂದಿರುತ್ತದೆ ಮತ್ತು ಅವು ಒಂದು ಕುರ್ಚಿಯಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ (ಒಂದು ಬೈಟ್ ಅನ್ನು ತೆಗೆದುಕೊಳ್ಳಿ), ಮತ್ತು ಉದ್ದವಾದ ಡಬಲ್ ಪ್ರಕಾರದ ಕೊಬ್ಬಿನ ಸಂದರ್ಶಕರು ದೊಡ್ಡ ಬಟ್‌ಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ ಮತ್ತು ಅವುಗಳಲ್ಲಿ ಪ್ರತಿಯೊಂದೂ 10 ಆಸನಗಳಲ್ಲಿ ಮಾತ್ರ ಹೊಂದಿಕೊಳ್ಳುತ್ತವೆ. ದಷ್ಟಪುಷ್ಟ ಚಿತ್ರಪ್ರೇಮಿಗಳಿಗೆ ಅವರ ಸೀಟ್ ಸಂಖ್ಯೆಯನ್ನು ಕೇಳಿದಾಗ, ಅವರು ಮೊದಲ ಸೀಟಿನ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ಹೇಳುತ್ತಾರೆ ಮತ್ತು ಸಂದರ್ಶಕರ ಬಿಲ್ಡ್ (ಡೇಟಾ ಪ್ರಕಾರ) ಆಧಾರದ ಮೇಲೆ ಇತರ ಎಲ್ಲಾ ಆಸನಗಳ ಸಂಖ್ಯೆ ಮತ್ತು ಸಂಖ್ಯೆಗಳನ್ನು ಸುಲಭವಾಗಿ ಲೆಕ್ಕ ಹಾಕಬಹುದು. ಸರಣಿಗಳನ್ನು ಒಂದೇ ರೀತಿಯ ಚಲನಚಿತ್ರ ಸಂದರ್ಶಕರ ಗುಂಪುಗಳಾಗಿ ಪ್ರತಿನಿಧಿಸಬಹುದು, ಉದಾಹರಣೆಗೆ, 10 ಜನರ ಚಾರ್ ಪ್ರಕಾರದ ತೆಳುವಾದ ಬ್ಯಾಲೆರಿನಾಗಳ ಗುಂಪು 10 ಸ್ಥಾನಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ ಏಕೆಂದರೆ ಚಾರ್ ಒಂದು ಕುರ್ಚಿಯಲ್ಲಿ ಹೊಂದಿಕೊಳ್ಳುತ್ತದೆ ಮತ್ತು 5 ಜನರನ್ನು ಒಳಗೊಂಡಿರುವ ಬಿಯರ್ ಪ್ರೇಮಿಗಳ ಗುಂಪು ಲಾಂಗ್ ಇಂಟ್ ಅನ್ನು ಟೈಪ್ ಮಾಡಿ 40 ಬೈಟ್‌ಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

6. & ಮತ್ತು * ನಿರ್ವಾಹಕರು ಹಲವಾರು ಜನಪ್ರಿಯ ಹೆಸರುಗಳನ್ನು ಹೊಂದಿದ್ದಾರೆ, ಆದರೆ ನೀವು ಅವರನ್ನು ವಾಸ್ಯಾ ಮತ್ತು ಪೆಟ್ಯಾ ಎಂದು ಕರೆಯಬಹುದು. ನೆನಪಿಡುವ ಮುಖ್ಯ ವಿಷಯವೆಂದರೆ:

& - ಸಿನಿಮಾ ಸಂದರ್ಶಕರು ಆಕ್ರಮಿಸಿಕೊಂಡಿರುವ ಮೊದಲ ಸೀಟಿನ ಸಂಖ್ಯೆಯನ್ನು ತೋರಿಸುತ್ತದೆ. ಅಂದರೆ, ಮೊದಲ ಆಕ್ರಮಿತ ಬೈಟ್‌ನ ವಿಳಾಸ.

* - ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಥಳದಲ್ಲಿ ಕುಳಿತುಕೊಳ್ಳುವ ಸಂದರ್ಶಕರನ್ನು ಉದ್ದೇಶಿಸಲು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಅಂದರೆ, ಮೆಮೊರಿಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ವಿಳಾಸದಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಮೌಲ್ಯವನ್ನು ಪಡೆಯಲು ಇದು ನಿಮ್ಮನ್ನು ಅನುಮತಿಸುತ್ತದೆ.

ಇದು ಲೇಖನವನ್ನು ಮುಕ್ತಾಯಗೊಳಿಸುತ್ತದೆ, ಆದರೆ ಸರಣಿಗಳು ಮತ್ತು ಪಾಯಿಂಟರ್‌ಗಳ ವಿಷಯವು ಪೂರ್ಣಗೊಂಡಿಲ್ಲ, ಸಂಪೂರ್ಣ ಸಿ ಭಾಷೆಯನ್ನು ಅಧ್ಯಯನ ಮಾಡುವುದು ಕಡಿಮೆ.

ಪ್ರತಿಕ್ರಿಯೆಗಳು

1. ಅನಾಮಧೇಯ ಹೇಳುತ್ತಾರೆ:
   

   ಈ ಎರಡು ಸರಣಿಗಳು ನಿಜವಾಗಿಯೂ ಒಂದೇ ಆಗಿವೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ:
   ಚಾರ್ ಚ = ('ಆರ್',"ಯು',"ಬಿ',"ವೈ',ಡಿ',ಇ','ವಿ','.'"ಆರ್',ಯು');
   ಚಾರ್ ch2 = "ಸೈಟ್";
   ಎರಡನೆಯ ಸಂದರ್ಭದಲ್ಲಿ, ರಚನೆಯು ಇನ್ನೂ ಒಂದು ಅಂಶವನ್ನು ಹೊಂದಿರುತ್ತದೆ, /0, ಇದನ್ನು ಪ್ರಿಂಟ್ ಮಾಡುವಾಗ, ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ನಕಲಿಸುವಾಗ ಡಿಲಿಮಿಟರ್ ಆಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

2. ನಿರ್ವಾಹಕ ಹೇಳುತ್ತಾರೆ:
   

   ವಾಸ್ತವವಾಗಿ, ಎರಡೂ ಅರೇಗಳು \0 ಅಕ್ಷರವನ್ನು 10 ನೇ ಅಂಶವಾಗಿ ಹೊಂದಿರುತ್ತವೆ, ಆದ್ದರಿಂದ ಅವು ನಿಜವಾಗಿಯೂ ಒಂದೇ ಆಗಿರುತ್ತವೆ, ಆದರೆ ನಾನು ಅಕ್ಷರ ಸರಣಿಗಳು ಮತ್ತು ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ ಮೀಸಲಾಗಿರುವ ಪ್ರತ್ಯೇಕ ಲೇಖನದಲ್ಲಿ \0 ಅಕ್ಷರದ ಬಗ್ಗೆ ಮಾತನಾಡುತ್ತೇನೆ.

3. ಅನಾಮಧೇಯ ಹೇಳುತ್ತಾರೆ:
   

   ಹೌದು, ನೀವು ಹೇಳಿದ್ದು ಸರಿ, ನಾನು GCC ಯಲ್ಲಿ ಈ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸುವ ಮೊದಲು ನಾನು ಆ ಕಾಮೆಂಟ್ ಅನ್ನು ಬರೆದಿದ್ದೇನೆ:
   #ಸೇರಿಸು
   #ಸೇರಿಸು

   ಇಂಟ್ ಮುಖ್ಯ (ಶೂನ್ಯ)
   {
   ಚಾರ್ ಚ = ('ಆರ್',"ಯು', ಬಿ', 'ವೈ', 'ಡಿ', 'ಇ', 'ವಿ', '.', 'ಆರ್', 'ಯು');
   ಚಾರ್ ch2 = "ಸೈಟ್";

   printf("%x\n", ch[ strlen(ch) ]);

   ಹಿಂತಿರುಗಿ 0;
   }
   ಶೂನ್ಯವನ್ನು ಮುದ್ರಿಸುತ್ತದೆ.

4. ನಿರ್ವಾಹಕ ಹೇಳುತ್ತಾರೆ:
   

   ಅತ್ಯಂತ ಆಸಕ್ತಿದಾಯಕ ವಿಷಯವೆಂದರೆ ನೀವು ANSI C ವಿವರಣೆಯನ್ನು ನಂಬಿದರೆ, ನೀವು ಸರಿಯಾಗಿರುತ್ತೀರಿ ಏಕೆಂದರೆ ಸರಣಿಗಳಿಗೆ ಪ್ರಮಾಣಿತ ರೀತಿಯಲ್ಲಿ ರಚಿಸಲಾದ ಅಕ್ಷರಗಳ ಸರಣಿಯ ಅಂತ್ಯಕ್ಕೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಸೇರಿಸುವ ಬಗ್ಗೆ ಅದು ಏನನ್ನೂ ಹೇಳುವುದಿಲ್ಲ (ಮತ್ತು K&R ನಲ್ಲಿ ಇದು ಎರಡೂ ಆವೃತ್ತಿಗಳಲ್ಲಿ ಸ್ಪಷ್ಟವಾಗಿ ಮಾಡಲಾಗುತ್ತದೆ). ಇದು C99 ಅಥವಾ ಕಂಪೈಲರ್‌ನಲ್ಲಿ ವ್ಯತ್ಯಾಸವಾಗಿದೆ ಎಂದು ನಾನು ಭಾವಿಸುತ್ತೇನೆ, ಏಕೆಂದರೆ ಕಂಪೈಲರ್ ತಯಾರಕರು C99 ನ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೆಚ್ಚಾಗಿ ಭಾಗಶಃ ಅಳವಡಿಸುತ್ತಾರೆ ಮತ್ತು ಕೆಲವರು ತಮ್ಮದೇ ಆದದನ್ನು ಸೇರಿಸುತ್ತಾರೆ. ಕಂಪೈಲರ್ನ ಆಯ್ಕೆಯು ಏಕೆ ಮುಖ್ಯವಾಗಿದೆ ಎಂಬುದು ಈಗ ಸ್ಪಷ್ಟವಾಗಿದೆ. ನಾನು ಈ ಸಮಸ್ಯೆಯ ಕುರಿತು ನಂತರ ಕೆಲಸ ಮಾಡಬೇಕಾಗಿದೆ ಮತ್ತು C ಕಂಪೈಲರ್‌ಗಳ ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳು, C99 ಗೆ ಅವರ ಬೆಂಬಲ ಮತ್ತು ANSI C ಮತ್ತು C 99 ನಡುವಿನ ವ್ಯತ್ಯಾಸಗಳ ಬಗ್ಗೆ ಲೇಖನವನ್ನು ಬರೆಯಬೇಕಾಗಿದೆ.

5. ನಿರ್ವಾಹಕ ಹೇಳುತ್ತಾರೆ:
   

   ನಾನು ತನಿಖೆ ನಡೆಸಿದೆ, ಆದರೆ ನಾನು ಇನ್ನೂ ನಿಮಗೆ ತಪ್ಪು ಮಾಹಿತಿ ನೀಡಿದ್ದೇನೆ. ಸಾಂಪ್ರದಾಯಿಕ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನಲ್ಲಿ, \0 ಅನ್ನು ಸೇರಿಸಲಾಗಿಲ್ಲ, ಸ್ಟಾಕ್‌ನಲ್ಲಿನ ಮುಂದಿನ ಅಕ್ಷರವು \0 ಆಗಿರುವುದು ಕೇವಲ ಕಾಕತಾಳೀಯವಾಗಿದೆ, ಆದರೆ ಇದು ಅಕ್ಷರ ರಚನೆಯ ಭಾಗವಾಗಿಲ್ಲ. ನೀವು strlen() ಅನ್ನು ಬಳಸಿದರೆ, ಸಾಂಪ್ರದಾಯಿಕ ರಚನೆಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ನಡುವಿನ 1 ಅಕ್ಷರದ ವ್ಯತ್ಯಾಸವನ್ನು ನೀವು ಸ್ಪಷ್ಟವಾಗಿ ನೋಡಬಹುದು. ಅಲ್ಲಿ ಅಕ್ಷರಗಳನ್ನು ಸರಳವಾಗಿ ಪಟ್ಟಿಮಾಡಲಾಗುತ್ತದೆ ಮತ್ತು ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರವನ್ನು ಬಳಸುತ್ತದೆ. ಸ್ಟ್ರಿಂಗ್ ಸ್ಥಿರಾಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ರಚಿಸಲಾದ ಅಕ್ಷರ ರಚನೆಯ ಅಂತ್ಯಕ್ಕೆ ಮಾತ್ರ ಶೂನ್ಯ ಅಕ್ಷರವನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.

6. andr ಹೇಳುತ್ತಾರೆ:
   

   ಸಾಕಷ್ಟು ದಾರಿತಪ್ಪಿಸುವ ಹೇಳಿಕೆಗಳು. ಅಂತಹ ಲೇಖನಗಳು ಅನನುಭವಿ ಪ್ರೋಗ್ರಾಮರ್ಗಳನ್ನು ಮಾತ್ರ ಹಾಳುಮಾಡುತ್ತವೆ. :)
   ಉದಾಹರಣೆಗೆ, "ಸಂಗ್ರಹದ 5 ನೇ ಅಂಶ, ನಾವು ವಾಸ್ತವವಾಗಿ ಘೋಷಿಸಲಿಲ್ಲ, ಸಂಗ್ರಹಣೆಯ ಒಟ್ಟು ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ." - ಇವುಗಳು ಅಭೂತಪೂರ್ವ ಕಥೆಗಳು. ಸಿ ಭಾಷೆಯು ಅರೇಗಳ ಉದ್ದವನ್ನು ಎಲ್ಲಿಯೂ ಸಂಗ್ರಹಿಸುವುದಿಲ್ಲ. ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, 'a' ಶ್ರೇಣಿಯು ಮಿತಿ ಮೀರಿದೆ ಏಕೆಂದರೆ ರಚನೆಯ 5 ಅಂಶಗಳಿಗೆ, ಕೊನೆಯ ಸೂಚ್ಯಂಕ == 4, ಮತ್ತು ನೀವು ಅದನ್ನು 5 ಕ್ಕೆ ಸೂಚಿಸಿ. ಹೀಗಾಗಿ, ನೀವು ವೇರಿಯಬಲ್ i ನ ವಿಳಾಸವನ್ನು ಪ್ರವೇಶಿಸುತ್ತೀರಿ, ಕಂಪೈಲರ್ ರಚನೆಯ ನಂತರ ತಕ್ಷಣವೇ ಮೆಮೊರಿಯಲ್ಲಿ ಇರಿಸಲಾಗುತ್ತದೆ, ಆದ್ದರಿಂದ ಕೊನೆಯ ಲೂಪ್‌ನಲ್ಲಿ (i == 5 ಇದ್ದಾಗ) ನೀವು ಪರಿಣಾಮವಾಗಿ 5 ಅನ್ನು ಪಡೆಯುತ್ತೀರಿ.

   "ನಾನು ಹೇಳಿದಂತೆ, C ಯಲ್ಲಿ ಯಾವುದೇ ಸಾಂಪ್ರದಾಯಿಕ ಸರಣಿಗಳಿಲ್ಲ, ಆದ್ದರಿಂದ C ಯ ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಒತ್ತಿಹೇಳಲು ನಾನು ಅವುಗಳನ್ನು ಸಂಗ್ರಹಣೆಗಳು ಎಂದು ಕರೆಯುತ್ತೇನೆ." - ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಗ್ರಹಿಸಲಾಗದ ವಿಷಯ. "ಸಾಂಪ್ರದಾಯಿಕ ಸರಣಿಗಳು" ಎಂದರೇನು? ಸಂಗ್ರಹಣೆಗಳು, ಮೂಲಕ, ವಿಶಾಲವಾದ ಪದವಾಗಿದೆ. ಅರೇಗಳು, ಪಟ್ಟಿಗಳು, ಮ್ಯಾಟ್ರಿಸಸ್, ಸ್ಟ್ಯಾಕ್‌ಗಳು ಮತ್ತು ಹ್ಯಾಶ್ ಕೋಷ್ಟಕಗಳು ಸಂಗ್ರಹಣೆಗಳ ವ್ಯಾಖ್ಯಾನಕ್ಕೆ ಸರಿಹೊಂದುತ್ತವೆ. ಅನುಚಿತವಾದ ನಿಯಮಗಳನ್ನು ಪರಿಚಯಿಸುವುದು ಮತ್ತು ಓದುಗರನ್ನು ಏಕೆ ದಾರಿ ತಪ್ಪಿಸುವುದು?

7. ನಿರ್ವಾಹಕ ಹೇಳುತ್ತಾರೆ:
   

   ಟಿಪ್ಪಣಿಗೆ ಧನ್ಯವಾದಗಳು andr. ನಾನು ಇತ್ತೀಚೆಗೆ ಸಿ ಕಲಿಯಲು ಪ್ರಾರಂಭಿಸಿದೆ ಮತ್ತು ಇವು ನನ್ನ ಊಹೆಗಳಾಗಿವೆ. ಸಿ ನನಗೆ ಸ್ವಲ್ಪ ಅಸಾಮಾನ್ಯವಾಗಿದೆ, ಅದಕ್ಕಾಗಿಯೇ ನಾನು ಅಂತಹ ದೋಷಗಳನ್ನು ಪಡೆಯುತ್ತೇನೆ. ನಾನು ಅದನ್ನು ಶೀಘ್ರದಲ್ಲೇ ಸರಿಪಡಿಸುತ್ತೇನೆ.

8. ಫೌಸ್ಟ್ಮನ್ ಹೇಳುತ್ತಾರೆ:
   

   ಸ್ಕಿನ್ನಿ ಬ್ಯಾಲೆರಿನಾಗಳು ಮತ್ತು ಬಿಯರ್ ಪ್ರೇಮಿಗಳ ಗುಂಪಿನ ಬಗ್ಗೆ ಚೆನ್ನಾಗಿ ಹೇಳಲಾಗಿದೆ!))

9. Myname ಹೇಳುತ್ತಾರೆ:
   

   ಮತ್ತು ನಾನು gcc a ಅನ್ನು ಹೊಂದಿದ್ದೇನೆ, ಅದು ನೀವು ಹೇಳಿದಂತೆ, ಅಂಶಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ, ಮೌಲ್ಯ 32767 ಅನ್ನು ಉತ್ಪಾದಿಸುತ್ತದೆ.

ಅರೇಗಳು C++ ನಲ್ಲಿ ಬಹಳ ಮುಖ್ಯವಾದ ವಿಷಯವಾಗಿದೆ. ಅವುಗಳನ್ನು ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲಿ ಹೆಚ್ಚಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ ಮತ್ತು ಈ ವಿಷಯವನ್ನು ಸಂಪೂರ್ಣವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಅವಶ್ಯಕ. ನಾನು ಈಗಿನಿಂದಲೇ ನಿಮ್ಮನ್ನು ಸಂತೋಷಪಡಿಸುತ್ತೇನೆ - ಅರೇಗಳನ್ನು ಹೇಗೆ ಬಳಸುವುದು ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಮತ್ತು ಕಲಿಯುವುದು ಹರಿಕಾರರಿಗೂ ತುಂಬಾ ಸರಳವಾಗಿದೆ.

ಆದ್ದರಿಂದ, ಸರಣಿಗಳು ಏಕೆ ಬೇಕು ಮತ್ತು ಅವು ಯಾವುವು? ಪ್ರೋಗ್ರಾಂ ಡೇಟಾವನ್ನು ನಲ್ಲಿ ಸಂಗ್ರಹಿಸಲಾಗಿದೆ ಎಂದು ಈಗ ನಿಮಗೆ ಚೆನ್ನಾಗಿ ತಿಳಿದಿದೆ. ಆದರೆ ಪ್ರೋಗ್ರಾಂ ಒಂದೇ ರೀತಿಯ ಡೇಟಾದ ನೂರಾರು (ಅಥವಾ ಇನ್ನೂ ಹೆಚ್ಚಿನ) ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ಸಂಗ್ರಹಿಸುವ ಅಗತ್ಯವಿದೆ ಮತ್ತು ಅವರೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬೇಕಾಗುತ್ತದೆ - ಮೌಲ್ಯಗಳನ್ನು ನಿಯೋಜಿಸಿ, ಅವುಗಳನ್ನು ಬದಲಾಯಿಸಿ, ಇತ್ಯಾದಿ.

ಉದಾಹರಣೆಗೆ, ನೀವು ಸಾಲುಗಳ ಸರಣಿ ಸಂಖ್ಯೆಗಳನ್ನು ಸಂಗ್ರಹಿಸಬೇಕಾಗುತ್ತದೆ. ಒಪ್ಪುತ್ತೇನೆ - ಟೈಪ್ ಇಂಟ್‌ನ ಐನೂರು ವೇರಿಯೇಬಲ್‌ಗಳನ್ನು ರಚಿಸುವ ಆಲೋಚನೆಯಿಂದ ಯಾರಾದರೂ ಭಯಪಡುತ್ತಾರೆ, ಪ್ರತಿಯೊಂದಕ್ಕೂ ವಿಶಿಷ್ಟವಾದ ಹೆಸರನ್ನು ನೀಡಿ ಮತ್ತು 1 ರಿಂದ 500 ರವರೆಗಿನ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುತ್ತಾರೆ. (ನಾನು ಈಗಾಗಲೇ ಭಯಗೊಂಡಿದ್ದೇನೆ :) ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಸರಣಿಗಳು ನಮ್ಮನ್ನು ಸರಳವಾಗಿ ಉಳಿಸುತ್ತವೆ.

ಮುಖ್ಯ ಅಂಶಗಳನ್ನು ಗಮನಿಸಿ ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗೆ ಹೋಗೋಣ:

• C++ ನಲ್ಲಿನ ರಚನೆಯು ಒಂದೇ ರೀತಿಯ ಹೆಸರನ್ನು ಹೊಂದಿರುವ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ವೇರಿಯಬಲ್‌ಗಳ ಸಂಗ್ರಹವಾಗಿದೆ. ಉದಾಹರಣೆಗೆ, ಇಂಟ್ ಅರೇ;. ಈ ನಮೂದು ಎಂದರೆ ನಾವು ಹೆಸರಿನ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿದ್ದೇವೆ ಶ್ರೇಣಿ, ಇದುಒಳಗೊಂಡಿದೆ 3 ಟೈಪ್ ಅಸ್ಥಿರ ಇಂಟ್ ;
• ರಚನೆಯ ಅಸ್ಥಿರಗಳನ್ನು ಅಂಶಗಳು ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ;
• ಪ್ರತಿಯೊಂದು ಅಂಶವು ತನ್ನದೇ ಆದ ವಿಶಿಷ್ಟ ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದೆ - ಅದರ ಸ್ವಂತ ಸರಣಿ ಸಂಖ್ಯೆ. ಸೂಚ್ಯಂಕವನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ನಿರ್ದಿಷ್ಟ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸಬಹುದು. ಪ್ರಮುಖ - ರಚನೆಯ ಅಂಶಗಳ ಸೂಚಿಕೆ 0 ರಿಂದ ಪ್ರಾರಂಭವಾಗುತ್ತದೆ . ಆದ್ದರಿಂದ ರಚನೆಯಲ್ಲಿ ಇಂಟ್ ಅರೇಮೊದಲ ಅಂಶವು ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿದೆ 0 , ಮತ್ತು ಕೊನೆಯದು 2 . ಉದಾಹರಣೆಗೆ, ರಚನೆಯ ಶೂನ್ಯ ಅಂಶವನ್ನು ಪ್ರವೇಶಿಸಲು ಮತ್ತು ಅದರ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸಲು, ನೀವು ರಚನೆಯ ಹೆಸರನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಬೇಕು ಮತ್ತು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಅಂಶದ ಸೂಚಿಯನ್ನು ಸೂಚಿಸಬೇಕು - ಅರೇ = 33 .

ಒಂದು ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ:

C++ ಅರೇಗಳು

// ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾವು ಗಾತ್ರದ ಗಾತ್ರದೊಂದಿಗೆ ಸರಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ, // ಫಾರ್ ಲೂಪ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನಾವು ಎಲ್ಲಾ ಕೋಶಗಳಿಗೆ ಡೇಟಾವನ್ನು ನಮೂದಿಸುತ್ತೇವೆ // ರಚನೆಯ ಮತ್ತು ಅವುಗಳ ವಿಷಯಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತೇವೆ #include ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; int main() (setlocale(LC_ALL, "rus"); const int SIZE = 10; // ಸ್ಥಿರವಾದ ಇಂಟ್ ಫಸ್ಟ್ಅರೇ ಅನ್ನು ಘೋಷಿಸಿ; // (int i = 0; i ಗಾಗಿ SIZE ಅಂಶಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿ< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

// ಈ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ನಾವು ಗಾತ್ರದ ಗಾತ್ರದೊಂದಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತೇವೆ, // ಎಲ್ಲಾ ಕೋಶಗಳಿಗೆ ಡೇಟಾವನ್ನು ನಮೂದಿಸಲು ಫಾರ್ ಲೂಪ್ ಅನ್ನು ಬಳಸಿ // ರಚನೆ ಮತ್ತು ಅವುಗಳ ವಿಷಯಗಳನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸಿ #ಸೇರಿಸು ನೇಮ್‌ಸ್ಪೇಸ್ ಎಸ್‌ಟಿಡಿಯನ್ನು ಬಳಸುವುದು; ಇಂಟ್ ಮುಖ್ಯ() ಸೆಟ್ಲೊಕೇಲ್(LC_ALL, "ರುಸ್"); const int SIZE = 10 ; // ಸ್ಥಿರವನ್ನು ಘೋಷಿಸಿ ಇಂಟ್ ಫಸ್ಟ್ಅರೇ[SIZE]; // SIZE ಅಂಶಗಳ ಸಂಖ್ಯೆಯೊಂದಿಗೆ ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಿ ಗಾಗಿ (int i = 0; i< SIZE ; i ++ ) // ಪರದೆಯ ಮೇಲೆ ಮೌಲ್ಯಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ ಮತ್ತು ಪ್ರದರ್ಶಿಸಿ ಮೊದಲ ಶ್ರೇಣಿ[i] = i+1; // ಲೂಪ್‌ನ ಮೊದಲ ಹಂತದಲ್ಲಿ firstArray 1 (0 + 1) ಅನ್ನು ನಿಯೋಜಿಸಿ ಕೌಟ್<< i << "-ನೇ ಕೋಶವು ಸಂಖ್ಯೆಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ"<< firstArray [ i ] << endl ; ಕೌಟ್<< endl ; ಹಿಂತಿರುಗಿ 0;

12 ನೇ ಸಾಲಿನಲ್ಲಿ ನಾವು ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸುತ್ತೇವೆ ಗಾತ್ರ, ಇದು ರಚನೆಯ ಗಾತ್ರವನ್ನು ಸಂಗ್ರಹಿಸುತ್ತದೆ (ನಮ್ಮಿಂದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ, ಅದರ ಅಂಶಗಳ ಸಂಖ್ಯೆ). 13 ನೇ ಸಾಲಿನಲ್ಲಿ ನಾವು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುತ್ತೇವೆ: ರಚನೆಯ ಕೋಶಗಳಲ್ಲಿ ಸಂಗ್ರಹವಾಗಿರುವ ಡೇಟಾದ ಪ್ರಕಾರವನ್ನು ನಾವು ಸೂಚಿಸುತ್ತೇವೆ, ಹೆಸರನ್ನು ನೀಡಿ ಮತ್ತು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಗಾತ್ರವನ್ನು ಸೂಚಿಸುತ್ತೇವೆ.

ನಾವು ಸ್ಥಿರ ಪೂರ್ಣಾಂಕ ಮೌಲ್ಯಗಳನ್ನು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ಮಾತ್ರ ಬರೆಯಬಹುದು ಎಂಬುದು ಮುಖ್ಯ. ಒಂದು ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸುವಾಗ ನೀವು ತಕ್ಷಣವೇ ಒಂದು ಪೂರ್ಣಾಂಕವನ್ನು ಚೌಕ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ನಮೂದಿಸಬೇಕು ( ಇಂಟ್ ಫಸ್ಟ್ಅರೇ;), ಅಥವಾ ಸರಣಿಯನ್ನು ಘೋಷಿಸುವ ಮೊದಲು ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಿ ಮತ್ತು ಈ ಸ್ಥಿರದ ಹೆಸರನ್ನು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ನಮೂದಿಸಿ (ನಮ್ಮ ಉದಾಹರಣೆಯಂತೆ).

ಪ್ರೋಗ್ರಾಂನ ಅವಧಿಯಲ್ಲಿ ನೀವು ಲೂಪ್ ಮೂಲಕ ಹಲವಾರು ಬಾರಿ ಶ್ರೇಣಿಯನ್ನು ಪ್ರವೇಶಿಸಬೇಕಾದರೆ ಎರಡನೆಯ ವಿಧಾನವು ಬಳಸಲು ಯೋಗ್ಯವಾಗಿದೆ. ನಾವು ಲೂಪ್ ಅನ್ನು ಘೋಷಿಸಿದಾಗ, ಕೌಂಟರ್ ಅನ್ನು ಮೌಲ್ಯಕ್ಕೆ ಬದಲಾಯಿಸುವ ಸ್ಥಿತಿಯನ್ನು ನಾವು ಅದರಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಬಹುದು ಎಂಬ ಅಂಶದಿಂದ ಇದನ್ನು ವಿವರಿಸಲಾಗಿದೆ. ಗಾತ್ರ .

ನಾವು ರಚನೆಯ ಗಾತ್ರವನ್ನು 10 ಅಂಶಗಳಿಂದ 200 ಕ್ಕೆ ಬದಲಾಯಿಸಬೇಕಾಗಿದೆ ಎಂದು ಊಹಿಸಿ. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಮಾಡಬೇಕಾಗಿರುವುದು ಪೂರ್ಣಾಂಕ ಸ್ಥಿರಾಂಕದ ಮೌಲ್ಯವನ್ನು ಬದಲಾಯಿಸುವುದು ಮತ್ತು ಹೀಗಾಗಿ ನಾವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಹೊಸ ಗಾತ್ರದ ಮೌಲ್ಯಗಳನ್ನು ಬದಲಾಯಿಸುತ್ತೇವೆ ಅರೇ ಮತ್ತು ಪ್ರೋಗ್ರಾಂನ ಎಲ್ಲಾ ಲೂಪ್ಗಳಲ್ಲಿ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನೀವು ಯಾವುದೇ ಇತರ ಸಂಖ್ಯೆಯನ್ನು ಸ್ಥಿರಕ್ಕೆ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು ಗಾತ್ರ. ಮತ್ತು ಪ್ರೋಗ್ರಾಂ ಉತ್ತಮವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂದು ನೀವು ನೋಡುತ್ತೀರಿ - ನೀವು ನಿರ್ದಿಷ್ಟಪಡಿಸುವಷ್ಟು ಅಂಶಗಳೊಂದಿಗೆ ಇದು ಒಂದು ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುತ್ತದೆ, ಡೇಟಾವನ್ನು ನಮೂದಿಸಿ ಮತ್ತು ಅದನ್ನು ಪರದೆಯ ಮೇಲೆ ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಮತ್ತು ರಚನೆಯು ತುಂಬಾ ಚಿಕ್ಕದಾಗಿದ್ದರೆ, ಉದಾಹರಣೆಗೆ 5 ಅಂಶಗಳೊಂದಿಗೆ, ಘೋಷಣೆಯ ನಂತರ ನೀವು ಅದನ್ನು ತಕ್ಷಣವೇ ಪ್ರಾರಂಭಿಸಬಹುದು:

ಆದ್ದರಿಂದ 0 ಸೂಚ್ಯಂಕದೊಂದಿಗೆ ಅಂಶ - ಮೊದಲ ಶ್ರೇಣಿ- ಮೌಲ್ಯವನ್ನು ನಿಗದಿಪಡಿಸಲಾಗುತ್ತದೆ 11 , ಮತ್ತು ರಚನೆಯ ಕೊನೆಯ ಅಂಶ ಮೊದಲ ಶ್ರೇಣಿ- ಅರ್ಥ 1 5 . ಅಂತಹ ಟ್ರಿಕ್ ಇದೆ - ನೀವು ಚದರ ಬ್ರಾಕೆಟ್‌ಗಳಲ್ಲಿ ರಚನೆಯ ಗಾತ್ರವನ್ನು ಸೂಚಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಮತ್ತು ಇದನ್ನು ಬರೆಯಿರಿ:

ಹಿಂದಿನ ನಮೂದು ಇದಕ್ಕೆ ಸಮನಾಗಿರುತ್ತದೆ. ಎರಡನೆಯ ಸಂದರ್ಭದಲ್ಲಿ ಮಾತ್ರ ಕಂಪೈಲರ್ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಕರ್ಲಿ ಬ್ರೇಸ್‌ಗಳಲ್ಲಿನ ಡೇಟಾದ ಪ್ರಮಾಣವನ್ನು ಆಧರಿಸಿ ರಚನೆಯ ಗಾತ್ರವನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡುತ್ತದೆ.

ಅಲ್ಲದೆ, ರಚನೆಯ ಅಂಶಗಳ ಆರಂಭಿಕ ಪ್ರಾರಂಭದ ಸಮಯದಲ್ಲಿ, ರಚನೆಯನ್ನು "ಕಸ" (ಮೆಮೊರಿಯಲ್ಲಿರುವ ಇತರ ಪ್ರೋಗ್ರಾಂಗಳಿಂದ ಉಳಿದಿರುವ ಡೇಟಾ) ತೆರವುಗೊಳಿಸಬೇಕಾದಾಗ, ತಕ್ಷಣವೇ ಎಲ್ಲಾ ಅಂಶಗಳಿಗೆ ಮೌಲ್ಯವನ್ನು ನಿಯೋಜಿಸುವುದು ಉತ್ತಮ 0 . ಇದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ:

ಅಂತಹ ಪ್ರಾರಂಭವು ಸೊನ್ನೆಗಳನ್ನು ತುಂಬಲು ಮಾತ್ರ ಸಾಧ್ಯ ಎಂದು ನೆನಪಿನಲ್ಲಿಡಬೇಕು. ನೀವು ಕೆಲವು ಇತರ ಸಂಖ್ಯೆಗಳೊಂದಿಗೆ ರಚನೆಯ ಅಂಶಗಳನ್ನು ಭರ್ತಿ ಮಾಡಬೇಕಾದರೆ, ಲೂಪ್ ಅನ್ನು ಬಳಸುವುದು ಉತ್ತಮ. C++11 (ಕೋಡಿಂಗ್ ಸ್ಟ್ಯಾಂಡರ್ಡ್) ನಲ್ಲಿ, ಪಟ್ಟಿಯ ಪ್ರಾರಂಭವನ್ನು ಬಳಸುವಾಗ (ಕರ್ಲಿ ಬ್ರೇಸ್‌ಗಳೊಂದಿಗೆ ಪ್ರಾರಂಭಿಸುವಿಕೆ), ನಿಮಗೆ ಚಿಹ್ನೆಯನ್ನು ತ್ಯಜಿಸಲು ಸಹ ಅನುಮತಿಸಲಾಗಿದೆ = .

ಶ್ರೇಣಿಯನ್ನು ರಚಿಸುವಾಗ ನಾನು ಇನ್ನೂ ಒಂದು ಪ್ರಾರಂಭಿಕ ತಂತ್ರವನ್ನು ತೋರಿಸಲು ಬಯಸುತ್ತೇನೆ. ಉದಾಹರಣೆಗೆ, 30 ಅಂಶಗಳ ಒಂದು ಶ್ರೇಣಿಗಾಗಿ ನಾವು ಮೌಲ್ಯಗಳನ್ನು ನಮೂದಿಸಬೇಕಾಗಿದೆ 33 ಮತ್ತು 44 ಸೂಚ್ಯಂಕವನ್ನು ಹೊಂದಿರುವ ಕೋಶಗಳಿಗೆ ಮಾತ್ರ 0 ಮತ್ತು 1 ಅದರಂತೆ, ಮತ್ತು ಉಳಿದವನ್ನು ಸೊನ್ನೆಗಳೊಂದಿಗೆ ತುಂಬಿಸಿ. ನಂತರ ನಾವು ಇದನ್ನು ಮಾಡುತ್ತೇವೆ:

ಈ ಡೇಟಾವನ್ನು ಶೂನ್ಯ ಮತ್ತು ಮೊದಲ ಕೋಶಗಳಿಗೆ ನಮೂದಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ಉಳಿದವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ 0 .

ಆಪರೇಟರ್ ಅನ್ನು ಬಳಸಿಕೊಂಡು ನೀವು ರಚನೆಯ ಭರ್ತಿಯನ್ನು ಸಹ ಆಯೋಜಿಸಬಹುದು ಸಿನ್:

ಗಾಗಿ (int i = 0; i< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> ಮೊದಲ ಶ್ರೇಣಿ[i]; )

ಗಾಗಿ (int i = 0; i< size ; i ++ ) // ಪರದೆಯ ಮೇಲೆ ಮೌಲ್ಯಗಳನ್ನು ಭರ್ತಿ ಮಾಡಿ ಮತ್ತು ಪ್ರದರ್ಶಿಸಿ