Pembentukan tatasusunan c. Tatasusunan ialah himpunan unsur yang homogen. Bekerja dengan nilai daripada tatasusunan

Tatasusunan ialah struktur data yang diwakili sebagai sekumpulan sel daripada jenis yang sama, disatukan di bawah satu nama. Tatasusunan digunakan untuk memproses sejumlah besar data daripada jenis yang sama. Nama tatasusunan ialah penunjuk, saya akan memberitahu anda sedikit kemudian. Sel data individu tatasusunan dipanggil elemen tatasusunan. Unsur-unsur tatasusunan boleh menjadi data dari sebarang jenis. Tatasusunan boleh mempunyai satu atau lebih daripada satu dimensi. Bergantung pada bilangan dimensi, tatasusunan dibahagikan kepada tatasusunan satu dimensi, tatasusunan dua dimensi, tatasusunan tiga dimensi, dan seterusnya sehingga tatasusunan n-dimensi. Tatasusunan satu dimensi dan dua dimensi paling kerap digunakan dalam pengaturcaraan, jadi kami akan mempertimbangkan tatasusunan ini sahaja.

Tatasusunan satu dimensi dalam C++

Tatasusunan satu dimensi ialah tatasusunan dengan satu parameter yang mencirikan bilangan elemen tatasusunan satu dimensi. Sebenarnya, tatasusunan satu dimensi ialah tatasusunan yang boleh mempunyai hanya satu baris dan n bilangan lajur. Lajur dalam tatasusunan satu dimensi ialah elemen tatasusunan. Rajah 1 menunjukkan struktur tatasusunan satu dimensi integer a. Saiz tatasusunan ini ialah 16 sel.

Rajah 1 - Tatasusunan dalam C++

Ambil perhatian bahawa indeks maksimum tatasusunan satu dimensi a ialah 15, tetapi saiz tatasusunan ialah 16 sel, kerana penomboran sel tatasusunan sentiasa bermula dari 0. Indeks sel ialah integer bukan negatif yang mana anda boleh mengakses setiap sel tatasusunan dan melakukan sebarang tindakan padanya ( sel).

//sintaks untuk mengisytiharkan tatasusunan satu dimensi dalam C++: /*jenis data*/ /*nama tatasusunan satu dimensi*/; //contoh mengisytiharkan tatasusunan satu dimensi yang ditunjukkan dalam Rajah 1: int a;

di mana, int ialah integer;

A ialah nama tatasusunan satu dimensi;
16 ialah saiz tatasusunan satu dimensi, 16 sel.

Sentiasa sejurus selepas nama tatasusunan terdapat kurungan segi empat sama di mana saiz tatasusunan satu dimensi ditentukan; inilah yang membezakan tatasusunan daripada semua pembolehubah lain.

//cara lain untuk mengisytiharkan tatasusunan satu dimensi int mas, a;

Dua tatasusunan satu dimensi mas dan a diisytiharkan dengan saiz 10 dan 16, masing-masing. Selain itu, dalam kaedah pengisytiharan ini, semua tatasusunan akan mempunyai jenis data yang sama, dalam kes kami - int.

// tatasusunan boleh dimulakan apabila diisytiharkan: int a = ( 5, -12, -12, 9, 10, 0, -9, -12, -1, 23, 65, 64, 11, 43, 39, -15 ); // permulaan tatasusunan satu dimensi

Permulaan tatasusunan satu dimensi dilakukan dalam pendakap kerinting selepas tanda sama, setiap elemen tatasusunan dipisahkan daripada yang sebelumnya dengan koma.

Int a=(5,-12,-12,9,10,0,-9,-12,-1,23,65,64,11,43,39,-15); // memulakan tatasusunan tanpa menentukan saiznya.

Dalam kes ini, pengkompil itu sendiri akan menentukan saiz tatasusunan satu dimensi. Saiz tatasusunan hanya boleh ditinggalkan apabila memulakannya; apabila mengisytiharkan tatasusunan secara normal, saiz tatasusunan mesti ditentukan. Mari bangunkan atur cara mudah untuk memproses tatasusunan satu dimensi.

// array.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include << "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; }

// kod Kod::Blok

// Kod Dev-C++

// array.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #termasuk menggunakan ruang nama std; int utama(int argc, char* argv) ( cout<< "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; }

DALAM baris 10 - 11 Tatasusunan satu dimensi integer bernama array1 telah diisytiharkan dan dimulakan, saiznya ialah 16 sel, iaitu tatasusunan sedemikian boleh menyimpan 16 nombor. Sebarang pemprosesan tatasusunan hanya boleh dilakukan bersama dengan gelung. Gelung mana yang hendak dipilih untuk memproses tatasusunan terpulang kepada anda untuk memutuskan. Tetapi ia paling sesuai untuk tugas ini. Kami akan menggunakan pembilang pemboleh ubah pembilang untuk mengakses elemen tatasusunan satu dimensi1. Syarat untuk meneruskan gelung for mengandungi tanda ketaksamaan yang ketat, kerana tiada indeks keenam belas dalam tatasusunan tatasusunan satu dimensi1. Dan oleh kerana penomboran sel bermula dari sifar, terdapat 16 elemen dalam tatasusunan. Dalam badan gelung for, pengendali cout mencetak elemen tatasusunan satu dimensi (lihat Rajah 2).

Obrabotka massiva indeks elemen massiva array1 5 array1 -12 array1 -12 array1 9 array1 10 array1 0 array1 -9 array1 -12 array1 -1 array1 23 array1 65 array1 64 array1 11 array1 43 array1 39 array1 -15 Untuk meneruskan, tekan sebarang kekunci. . .

Rajah 2 - Tatasusunan dalam C++

Mari bangunkan atur cara lain untuk memproses tatasusunan satu dimensi dalam C++. Program mesti membaca sepuluh nombor yang dimasukkan secara berurutan dari papan kekunci. Semua nombor yang dimasukkan dijumlahkan dan hasilnya dipaparkan pada skrin.

// array_sum.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include << "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; }

// kod Kod::Blok

// Kod Dev-C++

// array_sum.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #termasuk menggunakan ruang nama std; int main(int argc, char* argv) ( int array1; // mengisytiharkan cout tatasusunan integer<< "Enter elementi massiva: " << endl; int sum = 0; for (int counter = 0; counter < 10; counter++) // цикл для считывания чисел cin >> tatasusunan1; // baca nombor yang dimasukkan daripada cout papan kekunci<< "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; }

Sebelum memproses tatasusunan, ia mesti diisytiharkan, dan saiz tatasusunan satu dimensi ialah 10, kerana ini ditentukan oleh keadaan tugas. Dalam pembolehubah jumlah kita akan mengumpul hasil tambah unsur-unsur tatasusunan satu dimensi. Gelung for pertama mengisi tatasusunan satu dimensi yang diisytiharkan dengan nombor yang dimasukkan daripada papan kekunci, baris 12 - 13. Pembolehubah pembilang digunakan untuk mengakses secara berurutan elemen tatasusunan satu dimensi1 , bermula dari indeks 0 dan sehingga inklusif ke-9. Gelung kedua untuk memaparkan elemen tatasusunan, baris 15 - 16. Gelung ketiga untuk secara berurutan membaca elemen tatasusunan satu dimensi dan menjumlahkannya, jumlahnya terkumpul dalam pembolehubah jumlah. baris 17 - 18. Keputusan program ditunjukkan dalam Rajah 3.

Masukkan elementi massiva: 0 1 2 3 4 5 6 7 8 9 tatasusunan1 = (0 1 2 3 4 5 6 7 8 9 ) sum = 45 Untuk meneruskan, tekan sebarang kekunci. . .

Rajah 3 - Tatasusunan dalam C++

Pertama, kesemua 10 nombor telah dimasukkan secara berurutan, selepas itu tatasusunan satu dimensi dipaparkan, dan jumlah nombor dalam tatasusunan telah dicetak.

Tatasusunan dua dimensi dalam C++

Sehingga tahap ini, kami telah mempertimbangkan tatasusunan satu dimensi, yang tidak boleh selalu terhad kepada. Katakan anda perlu memproses beberapa data daripada jadual. Jadual mempunyai dua ciri: bilangan baris dan bilangan lajur. Juga dalam tatasusunan dua dimensi, sebagai tambahan kepada bilangan elemen tatasusunan, terdapat ciri-ciri seperti bilangan baris dan bilangan lajur tatasusunan dua dimensi. Iaitu, secara visual, tatasusunan dua dimensi ialah jadual biasa, dengan baris dan lajur. Sebenarnya, tatasusunan dua dimensi ialah tatasusunan satu dimensi tatasusunan satu dimensi. Struktur tatasusunan dua dimensi, dinamakan a, bersaiz m dengan n ditunjukkan di bawah (lihat Rajah 4).

Rajah 4 - Tatasusunan dalam C++

di mana, m ialah bilangan baris tatasusunan dua dimensi;
n ialah bilangan lajur tatasusunan dua dimensi;
m * n — bilangan elemen tatasusunan.

// sintaks untuk mengisytiharkan tatasusunan dua dimensi /*jenis data*/ /*nama tatasusunan*/;

Dalam mengisytiharkan tatasusunan dua dimensi, serta dalam mengisytiharkan tatasusunan satu dimensi, pertama sekali, anda perlu menentukan:

jenis data;
nama tatasusunan.

Selepas itu, kurungan segi empat sama pertama menunjukkan bilangan baris tatasusunan dua dimensi, dan kurungan segi empat sama kedua menunjukkan bilangan lajur tatasusunan dua dimensi. Tatasusunan dua dimensi dibezakan secara visual daripada tatasusunan satu dimensi dengan pasangan kedua kurungan segi empat sama. Mari kita lihat contoh mengisytiharkan tatasusunan dua dimensi. Katakan kita perlu mengisytiharkan tatasusunan dua dimensi dengan bilangan elemen bersamaan dengan 15. Dalam kes ini, tatasusunan dua dimensi boleh mempunyai tiga baris dan lima lajur atau lima baris dan tiga lajur.

// contoh pengisytiharan tatasusunan dua dimensi: int a;

a ialah nama tatasusunan integer
nombor dalam kurungan persegi pertama menunjukkan bilangan baris tatasusunan dua dimensi, dalam kes ini terdapat 5;
nombor dalam kurungan segi empat sama kedua menunjukkan bilangan lajur tatasusunan dua dimensi, dalam kes ini terdapat 3.

// permulaan tatasusunan dua dimensi: int a = ( (4, 7, 8), (9, 66, -1), (5, -5, 0), (3, -3, 30), ( 1, 1, 1) );

Tatasusunan ini mempunyai 5 baris, 3 lajur. selepas tanda serah hak, kurungan kerinting am diletakkan, di dalamnya seberapa banyak pasangan kurungan kerinting diletakkan kerana sepatutnya terdapat garisan dalam tatasusunan dua dimensi, dan kurungan ini dipisahkan dengan koma. Dalam setiap pasangan pendakap kerinting, tulis elemen tatasusunan dua dimensi yang dipisahkan dengan koma. Dalam semua pendakap kerinting, bilangan elemen mestilah sama. Oleh kerana terdapat lima baris dalam tatasusunan, terdapat juga lima pasangan dalam kurungan. Tiga elemen ditulis dalam kurungan dalam, kerana bilangan lajur ialah tiga. Secara grafik, tatasusunan kami akan kelihatan seperti jadual dua dimensi (lihat Rajah 5).

Rajah 5 - Tatasusunan dalam C++

Dalam setiap sel tatasusunan dua dimensi a nilai ditunjukkan, alamat sel ini ditunjukkan di sudut kanan bawah. Alamat sel tatasusunan dua dimensi ialah nama tatasusunan, nombor baris dan nombor lajur.

Mari kita bangunkan program mudah untuk memproses tatasusunan dua dimensi, yang dipanggil "Labyrinth". Labirin mesti dibina berdasarkan tatasusunan dua dimensi. Kami akan memilih saiz labirin mengikut budi bicara kami.

// array2.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #include "stdafx.h" #include < 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) lain cout<< " "; // вывести два пробела cout << endl; } system("pause"); return 0; }

// kod Kod::Blok

// Kod Dev-C++

// array2.cpp: Mentakrifkan titik masuk untuk aplikasi konsol. #termasuk menggunakan ruang nama std; int main(int argc, char* argv) ( // 1-bersyarat "dinding labirin" // 2-"laluan yang betul, keluar dari labirin" // 0-"laluan palsu" int mas = ( (1, 2,1 ,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,), // permulaan tatasusunan dua dimensi ( 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,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,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,2 ,1,0,0,0,0,1,), (1,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,0 ,1,2,1, ), (1,2,1,2,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,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,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,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,1,) ); // dua gelung - dalaman dan luaran, mengakses setiap elemen tatasusunan untuk (int i = 0; i< 33; i++) //переключение по строкам { for (int j = 0; j < 20; j++)// переключение по столбцам if (mas[i][j] == 1) { // вывести два раза символ (номер которого 176 в таблице аски) в консоль cout << static_cast(176); cout<< static_cast(176); ) lain cout<< " "; // вывести два пробела cout << endl; } return 0; }

Laluan yang betul dan salah boleh dilambangkan dengan nombor yang sama, contohnya, sifar, tetapi untuk kejelasan, laluan yang betul dilambangkan dengan nombor 2. Tatasusunan dimulakan secara manual, hanya untuk memudahkan atur cara. Memandangkan atur cara memproses tatasusunan dua dimensi, dua gelung diperlukan untuk bertukar antara elemen tatasusunan dua dimensi. Yang pertama untuk suis gelung antara baris tatasusunan dua dimensi. Oleh kerana terdapat 33 baris dalam tatasusunan dua dimensi, pemboleh ubah pembilang i ditambah dari 0 hingga 33, baris 46. Di dalam gelung pertama ialah gelung for yang mengitar elemen baris tatasusunan dua dimensi. Dalam badan gelung kedua untuk, operasi penukaran jenis data unari dilakukan di dalam - static_cast<>() , yang mencetak nombor aksara 176. Operasi penukaran jenis data diduplikasi untuk menambah lebar labirin. Hasil program (lihat Rajah 6).

Rajah 6 - Tatasusunan dalam C++

Tatasusunan direka bentuk untuk menyimpan berbilang nilai daripada jenis yang sama. Sebagai contoh, dalam program Fahrenheit hingga Celsius, kami mengira nilai suhu purata daripada tiga. Jika tidak terdapat tiga nilai, tetapi lebih banyak lagi, maka di sinilah anda perlu menggunakan tatasusunan.

Sebelum anda boleh menggunakan tatasusunan, anda perlu mentakrifkannya. Takrif tatasusunan termasuk: jenis data yang disimpan dalam tatasusunan, nama tatasusunan dan bilangan elemen tatasusunan dalam kurungan segi empat sama:

int array;

Dalam kod ini, kami telah menentukan tatasusunan dengan tatasusunan pengecam (nama) sepuluh elemen jenis int.
Dalam bentuk ini, semua elemen tatasusunan masih tidak dimulakan. Untuk memulakannya apabila diisytiharkan, anda perlu menggunakan sintaks berikut:

int array = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9);

Dalam kes ini, elemen pertama tatasusunan diberikan nilai 0, dan yang terakhir - nilai 9.
Anda boleh menggunakan gelung untuk menetapkan nilai kepada elemen tatasusunan. Yang paling sesuai untuk ini ialah gelung for.

kod dalam bahasa c++ int array; //takrif tatasusunan untuk (int i = 0; i< 10; i++) { array[i] = i; }

Di sini kita mengakses setiap elemen tatasusunan melalui indeks - nombor dalam kurungan segi empat sama. Dengan setiap lelaran gelung, ia mengambil nilai dari sifar hingga 9.

Ambil perhatian bahawa penomboran indeks bermula dari sifar. Oleh itu, bilangan indeks sentiasa kurang satu daripada bilangan elemen tatasusunan.

Dengan pengecualian kurungan persegi dan subskrip, elemen tatasusunan digunakan sama seperti mana-mana pembolehubah.

rentetan

Sehingga kini, kami hanya boleh menyimpan rentetan dalam pemalar: "Contoh rentetan malar." Kami hanya boleh menyimpan satu aksara dalam pembolehubah - dalam jenis aksara. C++ menggunakan dua jenis rentetan: tatasusunan elemen jenis char dan jenis str. Buat masa ini kita akan fokus pada pilihan pertama.

Untuk menyimpan rentetan kita memerlukan tatasusunan. Ia kelihatan seperti ini:

rentetan char = ("s","t","p","o"."k","a");

Nasib baik ada cara yang lebih mudah :)

rentetan char = "rentetan";

Dalam kes ini, tatasusunan tujuh elemen akan dibuat secara automatik. Mengapa daripada tujuh? Intinya ialah setiap baris mesti berakhir dengan pemalar aksara "\0", yang mewakili bait kosong.

Dalam contoh sebelumnya, jika kita cuba memasukkan rentetan yang lebih besar daripada enam aksara ke dalam tatasusunan rentetan, tatasusunan akan melimpah kerana Anda tidak boleh menukar saiz tatasusunan semasa program sedang berjalan (walaupun tidak selalu):

rentetan char; // rentetan boleh menyimpan enam aksara dan "\0"

rentetan = "rentetan!"; // baris mengandungi tujuh aksara
Ia tidak disyorkan untuk melakukan ini :)

Ada satu lagi perkara yang saya ingin menarik perhatian anda. Apabila pengguna memasukkan rentetan, ruang dikira sebagai "\0". Kami tidak akan memasukkan rentetan dalam program kami lagi, jadi saya tidak akan menerangkan kes ini secara terperinci.

Tatasusunan tatasusunan (tatasusunan dua dimensi)

Nah, akhirnya kita sampai kepada perkara yang paling penting dalam isu ini.

Peta dalam permainan strategi (dan bukan sahaja) (RTS) dibahagikan kepada sel (dalam bahasa Inggeris - jubin). Adalah mudah untuk mewakili sel ini menggunakan tatasusunan dua dimensi.

Dalam contoh ini, kami akan terus bekerja dengan program pseudo_game dan, menggunakan tatasusunan dua dimensi, kami akan mensimulasikan peta di mana pemain boleh bergerak. Sehingga kini, "pergerakan" diwakili menggunakan koordinat x, y.

Kami akan mewakili sel dengan simbol. Saiz "kad" ialah 15x20. Tinggi lima belas, lebar dua puluh. Kami akan mewakili pemain dengan simbol T.

Mula-mula tambah fail pengepala stdlib.h.

Permainan pseudo_perbaikan

Saya akan memberikan hanya kepingan kod. Adalah dinasihatkan bahawa anda mempunyai program penuh di hadapan mata anda. Anda boleh menemuinya di bahagian "penyenaraian program" - pseudo_game_0_2. Ia menyusun dan berjalan. Hanya salin ke dalam editor IDE anda dan ikuti teks.

Permulaan data:

kod dalam bahasa c++ char act; // pembolehubah untuk membaca input pengguna int ch; // pembolehubah untuk menyimpan nilai yang dikurangkan bagi pembolehubah act int x = 0; // dua pembolehubah untuk menyimpan koordinat pemain int y = 0; peta char; // tatasusunan untuk menyimpan kad permainan // memulakan tatasusunan untuk (int i = 0; i< 15; i++) { for (int j = 0; j < 20; j++) { map[i][j] = " "; } } map = "T";

Di sini, pengendali baharu untuk kami ialah definisi tatasusunan dua dimensi. Tetapi ia hampir tidak berbeza dengan yang satu dimensi, hanya menambah sepasang kurungan segi empat sama. Dalam kurungan pertama kami menunjukkan bilangan baris, di kedua - bilangan lajur.

Selepas itu, dalam dua gelung, kami memulakan setiap elemen tatasusunan dengan nilai " " - yang hanya aksara ruang putih. Pertama, dalam gelung luar, kita melalui semua baris. Untuk setiap baris dalam gelung dalam, kami "merentasi" lajur.

Biar saya berikan contoh terperinci: selepas beberapa lelaran gelung luar, pembilang i menjadi sama dengan 9. Badan gelung luar mula dilaksanakan: pembolehubah j (pembilang gelung dalam) dimulakan kepada sifar, keadaan disemak dan badan gelung dalam dilaksanakan: map = " ";, Iaitu, aksara pertama (indeks sifar) baris kesepuluh (jangan lupa bahawa undur adalah dari sifar) diberikan ruang. Kemudian, pembilang j diberikan 1, badan gelung dilaksanakan... dan seterusnya sehingga pembilang j menjadi sama dengan 20 - syarat tidak dipenuhi dan gelung dalam terkeluar. Kemudian kaunter luaran dinaikkan. Kini ia bersamaan dengan 10 dan badan gelung luar dilaksanakan semula...

Selepas pemulaan dengan ruang, kami meletakkan watak permainan kami di lajur pertama baris pertama.

Pada permulaan gelung utama, kami memanggil fungsi system() untuk mengosongkan skrin keluaran sebelumnya.

Kemudian terdapat dua kitaran yang serupa dengan kitaran permulaan. Ia digunakan untuk memaparkan elemen tatasusunan pada skrin. Satu-satunya perbezaan yang ketara ialah keluaran aksara baris baharu pada penghujung badan gelung pertama.

Nah, maka terdapat percabangan di mana ia ditentukan kekunci mana yang ditekan. Cawangan itu sendiri telah berubah sedikit sejak kali terakhir, tetapi terdapat perbezaan dalam kandungan blok: pertama, kami memberikan ruang kepada koordinat di mana objek itu berada. Iaitu, kita membersihkan tempat sebelumnya. Kemudian kita menukar salah satu koordinat. Dan kemudian, kepada elemen tatasusunan dengan indeks baharu, kami menetapkan aksara "T".

Contoh untuk kod "75" - pergerakan ke kiri:

kod dalam bahasa c++ jika lain (ch == 75) ( peta[x][y] = " "; y--; peta[x][y] = "T"; )

Nah, itu pada asasnya. Pada masa ini kami mempunyai peta 15x20 di mana anda boleh menggunakan anak panah untuk menggerakkan watak - huruf "T". Tidak buruk untuk pelajaran keenam! Aplikasi ini akan menjadi asas untuk semua program konsol kami. Tidak akan ada penambahbaikan grafik. Anda tidak boleh mendapatkan lebih banyak daripada konsol DOS, dan kami tidak akan mempertimbangkan konsol Windows. Ini akan menjimatkan masa dan usaha dengan ketara.

Saya telah mengulas secara terperinci mengenai program pseudo_game dan kemungkinan besar anda akan memahaminya tanpa kesukaran. Jika tidak, baca semula senarai program dan anda tidak akan memahami isu ini sehingga anda memahaminya :). Latihan akan membantu anda menyatukan bahan. Melakukan latihan adalah wajib. Jika ada yang kurang jelas, tulis ke e-mel saya - saya akan cuba membantu.

Latihan:

1. Dalam senarai lengkap program, saya menggunakan percabangan suis. Kod untuk satu jika blok cawangan juga ditunjukkan di sini. Tambah baki jika blok.

2. Kini program boleh menulis kepada elemen tatasusunan yang tidak wujud. Semak untuk meninggalkan had peta.

3. Untuk latihan, buat program yang melukis dua medan untuk pertempuran laut pada skrin. Yang pertama untuk pemain, yang kedua untuk musuh. Medan kedua hendaklah terletak di sebelah kanan medan pertama.
Isi sel dalam dengan ruang. Untuk melukis sempadan, gunakan garis tolak dan pembahagi lurus: -, |, dan untuk sudut, gunakan cincang #. Di sebelah kiri setiap medan adalah timbunan nombor; di atas adalah huruf.
Anda mungkin memerlukan beberapa gelung untuk memulakan keseluruhan medan. Inilah rupa kod untuk mengisi lajur nombor dalam medan kedua:

kod dalam bahasa c++ rentetan int; // pembolehubah mewakili baris int lajur; // pembolehubah mewakili lajur peta char; lajur = 15; untuk (rentetan = 2; rentetan< 12; string++) { map = string - 1; }

Apakah tatasusunan dalam C?

Bagaimana untuk mengisytiharkan tatasusunan dalam C?

Bagaimana untuk memulakan tatasusunan dalam C?

Tatasusunan dalam C untuk boneka.

Tatasusunan dalam C

Tatasusunan dalam C ialah koleksi elemen dari jenis yang sama yang boleh diakses oleh indeks. Elemen tatasusunan dalam C terletak satu demi satu dalam ingatan komputer.

Contoh mudah untuk mencipta dan mengisi tatasusunan dalam C:

// @author Subbotin B.P..h> void main(void) ( 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); return 0 ;)

Kita mendapatkan:

Dalam contoh, kami mengisytiharkan tatasusunan yang mengandungi unsur jenis int:

di sini nama tatasusunan ialah nArr, bilangan elemen tatasusunan ialah tiga, jenis elemen tatasusunan ialah int.

Tatasusunan ialah himpunan elemen. Setiap elemen tatasusunan boleh dirujuk dengan nombornya. Nombor itu biasanya dipanggil indeks. Elemen tatasusunan dinomborkan bermula dari sifar. Mari kita tetapkan nilai kepada elemen pertama tatasusunan, dan elemen pertama mempunyai indeks sifar:

Mari kita tetapkan nilai kepada elemen kedua tatasusunan, dan elemen kedua mempunyai indeks satu:

Mari kita tetapkan nilai kepada elemen ketiga tatasusunan, dan elemen ketiga mempunyai indeks dua:

Apabila kami memaparkan elemen tatasusunan pada skrin, kami mendapat nilainya. seperti ini:

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

Untuk mendapatkan elemen tatasusunan, anda perlu menentukan nama tatasusunan dan indeks elemen:

Ini adalah elemen pertama tatasusunan, kerana elemen pertama mempunyai indeks sifar.

Mari kita tetapkan nilai elemen ketiga tatasusunan kepada pembolehubah int a:

indeks bagi elemen ketiga tatasusunan adalah sama dengan dua, kerana indeks dikira daripada sifar.

Sekarang peraturan umum untuk mengisytiharkan tatasusunan dalam C: apabila mengisytiharkan tatasusunan, anda perlu menunjukkan namanya, jenis elemen dan bilangan elemen. Bilangan unsur ialah nombor asli, i.e. keseluruhannya adalah positif. Sifar tidak boleh menjadi bilangan elemen. Anda tidak boleh menentukan bilangan pembolehubah elemen tatasusunan. Berikut ialah contoh pengisytiharan tatasusunan dalam C:

int nArr; // Tatasusunan telah diisytiharkan memegang seratus integer;
terapung fArr; // Tatasusunan yang direka untuk menyimpan 5 nombor apungan telah diisytiharkan;
char cArr; // Tatasusunan telah diisytiharkan untuk menyimpan dua aksara;

Ia akan menjadi satu kesilapan untuk mengisytiharkan tatasusunan dengan bilangan elemen yang berubah-ubah:

Int varElem;
int nArr; // Ralat! Bilangan elemen tidak boleh ditetapkan kepada pembolehubah;

Tetapi anda boleh menetapkan bilangan elemen dengan nilai malar: sama ada integer positif langsung 1, 2, 3... atau pemalar:

Const int arrayLength = 3;
int nArr;

Apabila mengisytiharkan tatasusunan dalam C, anda boleh segera memulakannya:

int nMassiv = (1, 2, 3);

Anda boleh meninggalkan bilangan elemen tatasusunan dalam kurungan segi empat sama jika semua elemen tatasusunan dimulakan:

int nMassiv = (1, 2, 3);

bilangan elemen akan ditentukan secara automatik dalam kes ini.

Anda boleh menentukan hanya sebahagian daripada elemen tatasusunan apabila mengisytiharkannya:

int nMassiv = (1, 2);

dalam contoh ini, dua elemen pertama tatasusunan dimulakan, tetapi yang ketiga tidak ditentukan.

Contoh tatasusunan aksara:

char cArr = ("S", "B", "P");

Apabila mengisytiharkan tatasusunan, anda tidak boleh menentukan bilangan elemen pembolehubah. Tetapi anda boleh menggunakan pembolehubah apabila mengakses elemen tatasusunan:

Int ind = 0;
char cr = cArr;

Ini digunakan apabila bekerja dengan gelung. Contoh:

// @author Subbotin B.P..h> void main(void) ( 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; }

Dalam contoh, dalam gelung pertama kita mengisi tatasusunan dengan elemen jenis int, dan dalam gelung kedua kita memaparkan elemen ini pada skrin.

Mengisytiharkan tatasusunan dalam C
Array ialah jenis data sekunder. Tatasusunan dalam C ialah himpunan elemen bersaiz jelas bagi jenis tertentu. iaitu, tidak seperti tatasusunan dalam Ruby, tatasusunan dalam C adalah daripada jenis yang sama (ia menyimpan data hanya satu jenis) dan mempunyai panjang yang telah ditetapkan (saiz).

Dalam C, tatasusunan boleh dibahagikan secara kasar kepada 2 jenis: tatasusunan nombor dan tatasusunan aksara. Sudah tentu, pembahagian sedemikian adalah sewenang-wenangnya kerana simbol juga adalah integer. Tatasusunan aksara juga mempunyai sintaks yang sedikit berbeza. Di bawah ialah contoh pengisytiharan tatasusunan:

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 = "tapak";

Dalam kes pertama, kami mengisytiharkan tatasusunan integer (4 bait setiap nombor) bersaiz 100 elemen. Lebih tepat lagi, kami menyimpan memori untuk menyimpan 100 elemen jenis int.

Dalam kes kedua, kami menentukan tatasusunan 10 elemen integer dan segera memberikan nilai kepada elemen tatasusunan.

Dalam kes ketiga, kami menentukan tatasusunan aksara. Tiada rentetan dalam C, tetapi terdapat tatasusunan aksara yang menggantikan rentetan.

Dalam kes kedua, kami juga mengisytiharkan tatasusunan aksara menggunakan sintaks khas yang lebih ringkas. Tatasusunan ch dan ch2 hampir sama, tetapi terdapat satu perbezaan. Apabila kita menggunakan sintaks pemalar rentetan untuk mencipta tatasusunan, aksara \0 ditambah secara automatik pada penghujung tatasusunan aksara; apabila menggunakan sintaks pengisytiharan tatasusunan standard, kita sendiri mesti menambah \0 sebagai elemen terakhir tatasusunan aksara. Aksara \0 (null) digunakan untuk mengenal pasti penghujung baris. Kami akan bercakap tentang pukulan dengan lebih terperinci dalam artikel berasingan.

Mengakses elemen tatasusunan dalam C

Dalam C, mengakses elemen tatasusunan agak remeh dan serupa dengan cara ia dilakukan dalam kebanyakan bahasa pengaturcaraan lain. Selepas nama pembolehubah yang merujuk tatasusunan, kami menunjukkan indeks (juga dipanggil kunci) elemen dalam kurungan segi empat sama. Contoh di bawah menunjukkan cara kita mengakses elemen pertama tatasusunan:

#termasuk 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 = "tapak"; printf("%d\n", arr); printf(" %c\n", ch); )

Kod printf("%d\n", a); akan mencetak 2, bukan 1 kerana pengindeksan tatasusunan bermula dari 0 dan satu lagi pengesahan ini ialah baris printf("%c\n", ch); , yang akan mencetak aksara "R" - elemen sifar array ch.

Secara umum, pengisytiharan tatasusunan mempunyai sintaks berikut:

nama_pembolehubah jenis data[<количество_элементов>] = <список, элементов, массива>

Bilangan elemen tatasusunan dan senarai elemen diperlukan atribut pengisytiharan tatasusunan; lebih tepat lagi, mana-mana satu daripadanya diperlukan, tetapi bukan kedua-duanya sekali.

Untuk memahami struktur tatasusunan, anda perlu membiasakan diri dengan konsep penunjuk dalam C.

Penunjuk dalam C
Jenis data adalah perlu untuk dapat memperuntukkan sekeping memori dengan saiz tertentu untuk menyimpan data dan menentukan jenis datanya kerana tanpa definisi yang jelas adalah tidak jelas sama ada set sifar dan satu adalah nombor, simbol, atau sesuatu yang lain. Dalam kes ini, pembolehubah ialah rujukan kepada sekeping memori dengan saiz dan jenis tertentu, contohnya, pembolehubah int merujuk kepada kawasan memori 4-bait tertentu di mana integer disimpan, dan pembolehubah char merujuk kepada Kawasan memori 1-bait di mana aksara disimpan (kod aksara ).

Untuk mendapatkan alamat yang dirujuk oleh pembolehubah, kami menggunakan pengendali khas & - pengendali alamat, contoh:

#termasuk 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 = "tapak"; int num = 100500; printf("%p\n", &arr );)

Baris printf("%p\n", &arr); akan mencetak 0xbfbbe068. 0xbfbbe068 ialah perwakilan heksadesimal bagi alamat memori di mana nombor 100500 disimpan.

Penunjuk ialah jenis pembolehubah khas yang menyimpan bukan nilai biasa, tetapi alamatnya dalam ingatan.

#termasuk int main() ( int a, b; b = a = 10; printf("A: %p\n", &a); printf("B: %p\n", &b); )

$./program
A: 0xbfe32008
B: 0xbfe3200c

Dalam contoh di atas, kami memberikan pembolehubah a dan b nilai yang sama - nombor 10, tetapi pembolehubah a dan b merujuk kepada dua kawasan memori yang berbeza, iaitu, kami menyimpan nombor 10 dalam ingatan dua kali. Jika kita menukar nilai pembolehubah b, ia tidak akan menjejaskan pembolehubah a dan begitu juga sebaliknya. Ini berbeza daripada cara kita bekerja dengan pembolehubah dalam Ruby, di mana pembolehubah adalah rujukan kepada objek yang disimpan dalam ingatan, dan apabila menetapkan dalam gaya a = b = 10, kita mendapat satu objek - nombor 10 dan dua rujukan kepadanya.

#termasuk 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); )

Keputusan pelaksanaan:

$./program
A:
alamat: 0xbfed0fa8
nilai: 10
B:
alamat: 0xbfed0fa8
nilai: 10

Penunjuk dan Tatasusunan

Sebenarnya, C tidak mempunyai tatasusunan dalam erti kata ramai orang biasa. Sebarang tatasusunan dalam C hanyalah rujukan kepada unsur sifar tatasusunan. Contoh:

#termasuk int main() ( int a = (10,20,30); printf("a-Alamat:%p\n", &a); printf("a-Alamat:%p\n", &a); printf( "a-Nilai:%d\n", a); printf("a-Saiz:%d\n", saiz(a)); )

Keputusan:

$./program
a-Alamat:0xbfc029b4
a-Alamat:0xbfc029b4
a-Nilai:10
a-Saiz:12

Seperti yang anda lihat, saya tidak menipu anda, pembolehubah yang merujuk tatasusunan sebenarnya hanya merujuk kepada elemen sifarnya, iaitu, ia adalah penunjuk kepada alamat storan elemen pertama.

Apabila kita menjalankan program, sistem pengendalian menyediakan program dengan dua jumlah memori khas - timbunan dan timbunan. Program kami hanya menggunakan timbunan. Tindanan menyimpan nilai dalam cara yang teratur. Apabila kita mencipta tatasusunan, kita sebenarnya mencipta penunjuk kepada unsur sifar bagi koleksi elemen dan menyimpan memori untuk N bilangan elemen. Dalam contoh di atas, kami mencipta koleksi 3 elemen jenis int, i.e. Setiap elemen mengambil 4 bait memori. Apabila kami menggunakan fungsi sizeof(), yang mengembalikan saiz dalam bait hujah yang dihantar kepadanya, kami mendapat nilai 12 i.e. tatasusunan mengambil 12 bait memori: 3 elemen * 4 bait. Oleh kerana timbunan digunakan untuk menyimpan elemen koleksi, unsur-unsur disimpan mengikut tertib, iaitu, ia menduduki kawasan bersebelahan timbunan, yang bermaksud bahawa kita boleh menavigasi melalui koleksi mengetahui kedudukan elemen dan saiz koleksi. Contoh:

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

Keputusan:

$./program
a mempunyai 10 dalam 0xbfbeda88
a mempunyai 20 dalam 0xbfbeda8c
a mempunyai 30 dalam 0xbfbeda90
a mempunyai 40 dalam 0xbfbeda94
a mempunyai 10 dalam 0xbfbeda98
a mempunyai 5 dalam 0xbfbeda9c

Program ini mencetak maklumat kepada kami tentang tatasusunan 5 elemen: nombor elemen, nilai dan alamat memori. Beri perhatian kepada alamat elemen - inilah yang saya beritahu anda. Alamat adalah dalam satu baris dan setiap satu seterusnya lebih besar daripada yang sebelumnya sebanyak 4. Elemen ke-5 koleksi, yang sebenarnya tidak kami nyatakan, menyimpan jumlah keseluruhan elemen koleksi. Perkara yang paling menarik ialah kita juga boleh menggunakan penunjuk untuk melintasi tatasusunan. Contoh:

#termasuk 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); }

Nota

1. Sila ambil perhatian bahawa kami menetapkan penunjuk b bukan alamat tatasusunan a, tetapi nilai pembolehubah a itu sendiri, kerana a sebenarnya adalah penunjuk.

2. Penggunaan kurungan segi empat sama yang menunjukkan indeks unsur tatasusunan ialah gula sintaksis dalam C untuk akses yang lebih mudah dan mudah difahami kepada elemen koleksi.

3. Seperti yang telah saya katakan, tiada tatasusunan tradisional dalam C, jadi saya memanggilnya koleksi untuk menekankan ciri C ini.

4. Alamat 1 elemen tatasusunan adalah lebih besar daripada alamat 0 elemen tatasusunan dengan jumlah memori yang diperuntukkan untuk menyimpan elemen jenis ini. Kami bekerja dengan elemen jenis int, setiap satunya menggunakan 4 bait untuk disimpan. Alamat elemen tatasusunan dalam ingatan dan mana-mana data secara umum ialah alamat bait pertama memori yang diperuntukkan untuk penyimpanannya.

5. Untuk memudahkan pemahaman, bayangkan bahawa memori komputer ialah sebuah panggung wayang yang besar, dengan tempat duduk bernombor dari 0 hingga, katakan, 1_073_741_824. Data jenis char mempunyai punggung saiz biasa dan ia muat dalam satu kerusi (mengambil satu bait), dan pelawat gemuk jenis berganda panjang mempunyai punggung yang besar dan setiap daripada mereka hanya muat dalam 10 tempat duduk. Apabila penonton wayang gemuk ditanya nombor tempat duduk mereka, mereka hanya menyatakan nombor tempat duduk pertama dan nombor serta nombor semua tempat duduk lain boleh dikira dengan mudah berdasarkan binaan pelawat (jenis data). Susunan boleh diwakili sebagai kumpulan pelawat pawagam jenis yang sama, sebagai contoh, sekumpulan ballerina nipis jenis char 10 orang akan mengambil 10 tempat duduk kerana char muat di satu kerusi, dan sekumpulan penggemar bir yang terdiri daripada 5 orang taip long int akan mengambil masa 40 bait.

6. Pengendali & dan * mempunyai beberapa nama popular, tetapi anda boleh memanggil mereka Vasya dan Petya. Perkara utama yang perlu diingat ialah:

& — menunjukkan bilangan tempat duduk pertama yang diduduki oleh pengunjung pawagam. Iaitu, alamat bait pertama yang diduduki.

* — membolehkan anda menghubungi pelawat yang duduk di tempat tertentu. Iaitu, ia membolehkan anda mendapatkan nilai yang disimpan pada alamat tertentu dalam ingatan.

Ini menyimpulkan artikel, tetapi topik tatasusunan dan penunjuk belum selesai, lebih-lebih lagi mempelajari keseluruhan bahasa C.

Jawapan

tanpa nama berkata:
Semak sama ada kedua-dua tatasusunan ini benar-benar sama:
char ch = (‘R’,”u’,”b’,”y’,”D’,”e’,”v’,’.’,”r’,”u’);
char ch2 = "tapak";
Dalam kes kedua, tatasusunan mengandungi satu lagi elemen, /0, yang digunakan sebagai pembatas semasa mencetak, menyalin rentetan dan sebagainya.
admin berkata:
Sebenarnya, kedua-dua tatasusunan mengandungi aksara \0 sebagai elemen ke-10, jadi ia benar-benar sama, tetapi saya akan bercakap tentang aksara \0 dalam artikel berasingan yang didedikasikan untuk tatasusunan aksara dan rentetan.
tanpa nama berkata:
Ya, anda betul, saya menulis ulasan itu sebelum saya menyemak sendiri kod ini dalam GCC:
#termasuk
#termasuk

int utama (tidak sah)
{
char ch = (‘R’,”u’,”b’, ‘y’, ‘D’, ‘e’, ‘v’, ‘.’, ‘r’, ‘u’);
char ch2 = "tapak";

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

pulangan 0;
}
Mencetak sifar.
admin berkata:
Perkara yang paling menarik ialah jika anda mempercayai spesifikasi ANSI C, maka anda betul kerana ia tidak mengatakan apa-apa tentang menambah aksara nol secara automatik ke penghujung tatasusunan aksara yang dicipta dengan cara standard untuk tatasusunan (dan dalam K&R ini dilakukan secara eksplisit dalam kedua-dua versi). Saya rasa ini sama ada perbezaan dalam C99 atau dalam pengkompil, kerana pengeluar pengkompil melaksanakan keupayaan C99 sebahagian besarnya, dan ada yang menambah sesuatu yang tersendiri. Sekarang jelas mengapa pilihan pengkompil sangat penting. Saya perlu menyelesaikan isu ini kemudian dan menulis artikel tentang perbezaan antara penyusun C, sokongan mereka untuk C99 dan perbezaan antara ANSI C dan C 99.
admin berkata:
Saya telah menjalankan penyiasatan, tetapi saya masih salah maklumkan kepada anda. Dalam sintaks tradisional, \0 tidak ditambah, ia hanya kebetulan bahawa aksara seterusnya pada tindanan ialah \0, tetapi ia bukan sebahagian daripada tatasusunan aksara. Jika anda menggunakan strlen(), anda boleh melihat dengan jelas perbezaan 1 aksara antara sintaks penciptaan tatasusunan tradisional. di mana aksara hanya disenaraikan dan menggunakan pemalar rentetan. Aksara null ditambah secara automatik hanya pada penghujung tatasusunan aksara yang dibuat menggunakan pemalar rentetan.
andr berkata:
Banyak kenyataan yang mengelirukan. Artikel sedemikian hanya merosakkan pengaturcara baru. :)
Sebagai contoh, "Elemen ke-5 koleksi, yang sebenarnya tidak kami nyatakan, menyimpan jumlah keseluruhan elemen koleksi." - ini adalah kisah yang belum pernah terjadi sebelumnya. Bahasa C tidak menyimpan panjang tatasusunan di mana-mana sahaja. Dalam contoh ini, tatasusunan 'a' di luar had kerana untuk 5 elemen tatasusunan, indeks terakhir == 4, dan anda mengindeksnya kepada 5. Oleh itu, anda mengakses alamat pembolehubah i, yang pengkompil diletakkan dalam ingatan sejurus selepas tatasusunan, jadi pada gelung terakhir (apabila i == 5) anda mendapat 5 sebagai hasilnya.

"Seperti yang saya katakan, tiada tatasusunan tradisional dalam C, jadi saya memanggilnya koleksi untuk menekankan ciri C ini." - ini adalah sesuatu yang tidak dapat difahami sepenuhnya. Apakah "tatasusunan tradisional"? Koleksi, dengan cara ini, adalah istilah yang lebih luas. Tatasusunan, senarai, matriks, tindanan dan juga jadual cincang sesuai dengan definisi koleksi. Mengapa memperkenalkan istilah yang tidak sesuai dan mengelirukan pembaca?
admin berkata:
terima kasih atas nota andr. Saya baru sahaja mula belajar C dan ini adalah andaian saya. C agak luar biasa bagi saya, itulah sebabnya saya mendapat ralat sedemikian. Saya akan baiki segera.
faustman berkata:
Baik dikatakan tentang ballerina kurus dan sekumpulan pencinta bir!))
Nama saya berkata:
Dan saya mempunyai gcc a, yang, seperti yang anda katakan, menyimpan bilangan elemen, menghasilkan nilai 32767.

Tatasusunan ialah topik yang sangat penting dalam C++. Mereka digunakan sangat kerap dalam program dan adalah perlu untuk memahami topik ini dengan teliti. Saya akan menggembirakan anda serta-merta - memahami dan mempelajari cara menggunakan tatasusunan agak mudah walaupun untuk pemula.

Jadi, mengapa tatasusunan diperlukan dan apakah itu? Sekarang anda sudah sedia maklum bahawa data program disimpan dalam fail . Tetapi ia berlaku bahawa program perlu menyimpan ratusan (atau lebih) pembolehubah jenis data yang sama, dan juga perlu bekerja dengan mereka - menetapkan nilai, mengubahnya, dsb.

Sebagai contoh, anda perlu menyimpan nombor siri baris. Setuju - sesiapa sahaja akan takut dengan pemikiran mencipta lima ratus pembolehubah jenis int, memberikan setiap satu nama yang unik dan memberikan nilai dari 1 hingga 500. (Saya sudah takut :) Dalam kes ini, tatasusunan hanya akan menyelamatkan kita.

Mari kita perhatikan perkara utama dan teruskan kepada contoh praktikal:

Tatasusunan dalam C++ ialah himpunan bilangan pembolehubah tertentu daripada jenis yang sama yang mempunyai nama yang sama. Cth, int array ;. Entri ini bermakna kami telah mengisytiharkan tatasusunan bernama tatasusunan, yang mengandungi 3 jenis pembolehubah int ;
pembolehubah tatasusunan dipanggil elemen;
Setiap elemen mempunyai indeks tersendiri - nombor sirinya sendiri. Menggunakan indeks kita boleh mengakses elemen tertentu. PENTING - pengindeksan elemen tatasusunan bermula dari 0 . Jadi dalam array int array elemen pertama mempunyai indeks 0 , dan yang terakhir ialah 2 . Untuk mengakses, sebagai contoh, elemen sifar tatasusunan dan menukar nilainya, anda perlu menentukan nama tatasusunan dan menunjukkan indeks elemen dalam kurungan segi empat sama - tatasusunan = 33 .

Mari lihat contoh:

Tatasusunan C++

// dalam program ini kita mencipta tatasusunan dengan saiz saiz, // menggunakan gelung for kita memasukkan data ke dalam semua sel // tatasusunan dan memaparkan kandungannya pada skrin #include menggunakan ruang nama std; int main() ( setlocale(LC_ALL, "rus"); const int SIZE = 10; //deklarasikan pemalar int firstArray; //deklarasikan tatasusunan dengan bilangan elemen SIZE untuk (int i = 0; i< SIZE ; i++) //заполняем и отображаем значения на экран { firstArray[i] = i + 1; // на первом шаге цикла firstArray присвоить 1 (0 + 1) cout << i << "-я ячейка хранит число " << firstArray[i] << endl; } cout << endl; return 0; }

// dalam program ini kita mencipta tatasusunan dengan saiz saiz,

// gunakan gelung for untuk memasukkan data ke dalam semua sel

// tatasusunan dan paparkan kandungannya pada skrin

#termasuk

menggunakan ruang nama std ;

int utama()

setlocale(LC_ALL, "rus");

const int SAIZ = 10 ; //menyatakan pemalar

int firstArray[SAIZ]; //deklarasikan tatasusunan dengan bilangan elemen SIZE

untuk (int i = 0 ; i< SIZE ; i ++ ) //isi dan paparkan nilai pada skrin

firstArray[i] = i+1; // pada langkah pertama gelung tetapkan firstArray 1 (0 + 1)

cout<< i << "sel-th menyimpan nombor"<< firstArray [ i ] << endl ;

cout<< endl ;

pulangan 0;

Pada baris 12 kita mentakrifkan pemalar integer SAIZ, yang akan menyimpan saiz tatasusunan (ditakrifkan oleh kami, bilangan elemennya). Dalam baris 13 kami mengisytiharkan tatasusunan: kami menunjukkan jenis data yang akan disimpan dalam sel tatasusunan, memberi nama dan menunjukkan saiz dalam kurungan segi empat sama.

Adalah penting bahawa kita hanya boleh menulis nilai integer malar dalam kurungan segi empat sama. Anda mesti sama ada segera memasukkan integer dalam kurungan segi empat sama apabila mengisytiharkan tatasusunan ( int firstArray;), atau tentukan pemalar integer sebelum mengisytiharkan tatasusunan dan masukkan nama pemalar ini dalam kurungan segi empat sama (seperti dalam contoh kami).

Kaedah kedua adalah lebih baik untuk digunakan jika semasa program anda perlu mengakses tatasusunan beberapa kali melalui gelung. Ini dijelaskan oleh fakta bahawa apabila kita mengisytiharkan gelung, kita boleh menentukan di dalamnya syarat untuk menukar pembilang kepada nilai SAIZ .

Bayangkan kita perlu menukar saiz tatasusunan daripada 10 elemen kepada 200. Dalam kes ini, apa yang perlu kita lakukan ialah menukar nilai pemalar integer, dan dengan itu kita secara automatik akan menggantikan nilai saiz baharu kedua-duanya dalam tatasusunan dan dalam semua gelung program.

Dalam contoh kami, anda boleh cuba menambah sebarang nombor lain pada pemalar SAIZ. Dan anda akan melihat bahawa program ini akan berfungsi dengan baik - ia akan mencipta tatasusunan dengan seberapa banyak elemen yang anda tentukan, masukkan data dan paparkannya pada skrin.

Dan jika tatasusunan adalah sangat kecil, contohnya dengan 5 elemen, anda boleh memulakannya serta-merta selepas pengisytiharan:

Jadi elemen dengan indeks 0 – firstArray– akan diberikan nilai 11 , dan elemen terakhir tatasusunan firstArray- maksudnya 1 5 . Terdapat helah sedemikian - anda tidak boleh menunjukkan saiz tatasusunan dalam kurungan persegi dan tulis ini:

Entri sebelum ini setaraf dengan yang ini. Hanya dalam kes kedua, pengkompil secara automatik mengira saiz tatasusunan berdasarkan jumlah data dalam pendakap kerinting.

Selain itu, semasa pemulaan awal elemen tatasusunan, apabila tatasusunan perlu dibersihkan daripada "sampah" (sisa data daripada atur cara lain dalam ingatan), adalah lebih baik untuk segera memberikan nilai kepada semua elemen 0 . Ia kelihatan seperti ini:

Harus diingat bahawa permulaan sedemikian hanya mungkin untuk mengisi dengan sifar. Jika anda perlu mengisi elemen tatasusunan dengan beberapa nombor lain, lebih baik menggunakan gelung. Dalam C++11 (standard pengekodan), apabila menggunakan permulaan senarai (inisialisasi dengan pendakap kerinting), anda juga dibenarkan untuk membuang tanda = .

Saya ingin menunjukkan satu lagi teknik permulaan apabila membuat tatasusunan. Sebagai contoh, untuk tatasusunan 30 elemen kita perlu memasukkan nilai 33 Dan 44 hanya kepada sel dengan indeks 0 Dan 1 sewajarnya, dan isikan selebihnya dengan sifar. Kemudian kita lakukan ini:

data ini akan dimasukkan ke dalam sel sifar dan pertama, dan selebihnya akan mengambil nilai secara automatik 0 .

Anda juga boleh mengatur pengisian tatasusunan menggunakan operator cin:

untuk (int i = 0; i< size; i++) //заполняем и выводим значения на экран { cout << "Введите значение в ячейку №" << i << " :"; cin >> firstArray[i]; )

untuk (int i = 0 ; i< size ; i ++ ) //isi dan paparkan nilai pada skrin