Bagaimana cara menemukan panjang array?

Apakah ada cara untuk menemukan berapa banyak nilai yang dimiliki array? Mendeteksi apakah saya telah mencapai akhir array juga akan berfungsi.

Jika maksud Anda adalah array gaya-C, maka Anda dapat melakukan sesuatu seperti:

int a[7];
std::cout << "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl;

Ini tidak berfungsi pada pointer (artinya tidak akan berfungsi untuk salah satu dari berikut ini):

int *p = new int[7];
std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;

atau:

void func(int *p)
{
    std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;
}

int a[7];
func(a);

Di C ++, jika Anda menginginkan perilaku seperti ini, maka Anda harus menggunakan kelas kontainer; mungkin std::vector.

Seperti yang dikatakan orang lain, Anda dapat menggunakan sizeof(arr)/sizeof(*arr)tetapi ini akan memberi Anda jawaban yang salah untuk tipe pointer yang bukan array.

template<class T, size_t N>
constexpr size_t size(T (&)[N]) { return N; }

Ini memiliki properti bagus gagal dikompilasi untuk jenis non array (visual studio memiliki _countofyang melakukan ini). Itu constexprmembuat ini ekspresi waktu kompilasi sehingga tidak memiliki kelemahan atas makro (setidaknya tidak saya tahu).

Anda juga dapat mempertimbangkan menggunakan std::arraydari C ++ 11 yang memaparkan panjangnya tanpa overhead di atas array C asli.

C ++ 17 memiliki std::size()di <iterator>header yang melakukan hal yang sama dan berfungsi untuk wadah STL juga (terima kasih kepada @Jon C ).

Melakukan sizeof( myArray )akan memberi Anda jumlah total byte yang dialokasikan untuk array itu. Anda kemudian bisa mengetahui jumlah elemen dalam array dengan membaginya dengan ukuran satu elemen dalam array:sizeof( myArray[0] )

Meskipun ini adalah pertanyaan lama, ada baiknya memperbarui jawaban untuk C ++ 17. Di perpustakaan standar sekarang ada fungsi templated std::size(), yang mengembalikan jumlah elemen dalam wadah std atau array gaya-C. Sebagai contoh:

#include <iterator>

uint32_t data[] = {10, 20, 30, 40};
auto dataSize = std::size(data);
// dataSize == 4

Apakah ada cara untuk menemukan berapa banyak nilai yang dimiliki array?

Iya!

Mencoba sizeof(array)/sizeof(array[0])

Mendeteksi apakah saya telah mencapai akhir array juga akan berfungsi.

Saya tidak melihat cara apa pun untuk ini kecuali array Anda adalah array karakter (yaitu string).

PS: Dalam C ++ selalu gunakan std::vector. Ada beberapa fungsi bawaan dan fungsionalitas yang diperluas.

std::vectormemiliki metode size()yang mengembalikan jumlah elemen dalam vektor.

(Ya, ini adalah jawaban dari mulut ke mulut)

#include <iostream>

int main ()
{
    using namespace std;
    int arr[] = {2, 7, 1, 111};
    auto array_length = end(arr) - begin(arr);
    cout << "Length of array: " << array_length << endl;
}

Sejak C ++ 11, beberapa template baru diperkenalkan untuk membantu mengurangi rasa sakit ketika berhadapan dengan panjang array. Semuanya didefinisikan dalam tajuk <type_traits>.

• std::rank<T>::value

  Jika Tmerupakan tipe array, berikan nilai konstanta anggota sama dengan jumlah dimensi array. Untuk jenis lainnya, nilainya 0.

• std::extent<T, N>::value

  Jika Tmerupakan tipe array, berikan nilai konstanta anggota sama dengan jumlah elemen di sepanjang Ndimensi th array, jika Ndalam [0, std::rank<T>::value). Untuk jenis lain, atau jika Tarray yang tidak diketahui terikat sepanjang dimensi pertama dan N0, nilainya 0.

• std::remove_extent<T>::type

  Jika Tadalah array dari beberapa tipe X, berikan tipe typedef anggota sama dengan X, jika tidak tipe adalah T. Perhatikan bahwa jika Tarray multidimensi, hanya dimensi pertama yang dihapus.

• std::remove_all_extents<T>::type

  Jika Tarray multidimensi dari beberapa tipe X, berikan tipe typedef anggota sama dengan X, jika tidak tipe adalah T.

Untuk mendapatkan panjang pada dimensi array multidimensi apa pun, decltypedapat digunakan untuk digabungkan std::extent. Sebagai contoh:

#include <iostream>
#include <type_traits> // std::remove_extent std::remove_all_extents std::rank std::extent

template<class T, size_t N>
constexpr size_t length(T(&)[N]) { return N; }

template<class T, size_t N>
constexpr size_t length2(T(&arr)[N]) { return sizeof(arr) / sizeof(*arr); }

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};

    // New way
    constexpr auto l1 = std::extent<decltype(a)>::value;     // 5
    constexpr auto l2 = std::extent<decltype(a), 1>::value;  // 4
    constexpr auto l3 = std::extent<decltype(a), 2>::value;  // 3
    constexpr auto l4 = std::extent<decltype(a), 3>::value;  // 0

    // Mixed way
    constexpr auto la = length(a);
    //constexpr auto lpa = length(*a);  // compile error
    //auto lpa = length(*a);  // get at runtime
    std::remove_extent<decltype(a)>::type pa;  // get at compile time
    //std::remove_reference<decltype(*a)>::type pa;  // same as above
    constexpr auto lpa = length(pa);
    std::cout << la << ' ' << lpa << '\n';

    // Old way
    constexpr auto la2 = sizeof(a) / sizeof(*a);
    constexpr auto lpa2 = sizeof(*a) / sizeof(**a);
    std::cout << la2 << ' ' << lpa2 << '\n';

    return 0;
}

BTY, untuk mendapatkan jumlah total elemen dalam array multidimensi:

constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents<decltype(a)>::type);

Atau letakkan di templat fungsi:

#include <iostream>
#include <type_traits>
    

template<class T>
constexpr size_t len(T &a)
{
    return sizeof(a) / sizeof(typename std::remove_all_extents<T>::type);
}

int main()
{
    int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}};
    constexpr auto ttt = len(a);
    int i;
    std::cout << ttt << ' ' << len(i) << '\n';
    
    return 0;
}

Lebih banyak contoh cara menggunakannya dapat ditemukan dengan mengikuti tautan.

Ada juga cara TR1 / C ++ 11 / C ++ 17 (lihat Live on Coliru):

const std::string s[3] = { "1"s, "2"s, "3"s };
constexpr auto n       = std::extent<   decltype(s) >::value; // From <type_traits>
constexpr auto n2      = std::extent_v< decltype(s) >;        // C++17 shorthand

const auto     a    = std::array{ "1"s, "2"s, "3"s };   // C++17 class template arg deduction -- http://en.cppreference.com/w/cpp/language/class_template_argument_deduction
constexpr auto size = std::tuple_size_v< decltype(a) >;

std::cout << n << " " << n2 << " " << size << "\n"; // Prints 3 3 3

Alih-alih menggunakan fungsi array bawaan alias:

 int x[3] = {0, 1, 2};

Anda harus menggunakan kelas array dan template array. Mencoba:

#include <array>
array<type_of_the_array, number_of_elements_in_the_array> Name_of_Array = {};

Jadi sekarang jika Anda ingin menemukan panjang array, yang harus Anda lakukan adalah menggunakan fungsi ukuran di kelas array.

Name_of_Array.size();

dan itu harus mengembalikan panjang elemen dalam array.

Di C ++, menggunakan kelas std :: array untuk mendeklarasikan sebuah array, orang dapat dengan mudah menemukan ukuran array dan juga elemen terakhir.

#include<iostream>
#include<array>
int main()
{
    std::array<int,3> arr;

    //To find the size of the array
    std::cout<<arr.size()<<std::endl;

    //Accessing the last element
    auto it=arr.end();
    std::cout<<arr.back()<<"\t"<<arr[arr.size()-1]<<"\t"<<*(--it);

    return 0;
}

Faktanya, kelas array memiliki banyak fungsi lain yang memungkinkan kita menggunakan array sebagai wadah standar.
Referensi 1 ke C ++ std :: kelas array
Referensi 2 ke std :: kelas array
Contoh dalam referensi sangat membantu.

Ini adalah pertanyaan yang cukup lama dan legendaris dan sudah ada banyak jawaban luar biasa di sana. Tetapi seiring waktu ada fungsi baru yang ditambahkan ke bahasa, jadi kita harus terus memperbarui hal sesuai fitur baru yang tersedia.

Saya hanya memperhatikan ada yang belum menyebutkan tentang C ++ 20. Maka terpikir untuk menulis jawaban.

C ++ 20

Di C ++ 20, ada cara baru yang lebih baik ditambahkan ke perpustakaan standar untuk menemukan panjang array yaitu std:ssize(). Fungsi ini mengembalikan a signed value.

#include <iostream>

int main() {
    int arr[] = {1, 2, 3};
    std::cout << std::ssize(arr);
    return 0;
}

C ++ 17

Di C ++ 17 ada cara yang lebih baik (pada waktu itu) untuk hal yang sama yang std::size()didefinisikan dalam iterator.

#include <iostream>
#include <iterator> // required for std::size

int main(){
    int arr[] = {1, 2, 3};
    std::cout << "Size is " << std::size(arr);
    return 0;
}

PS Metode ini berfungsi untuk vector .

Tua

Pendekatan tradisional ini sudah disebutkan dalam banyak jawaban lain.

#include <iostream>

int main() {
    int array[] = { 1, 2, 3 };
    std::cout << sizeof(array) / sizeof(array[0]);
    return 0;
}

Hanya FYI, jika Anda bertanya-tanya mengapa pendekatan ini tidak berfungsi ketika array diteruskan ke fungsi lain . Alasannya adalah,

Array tidak diteruskan oleh nilai dalam C ++, sebaliknya pointer ke array dilewatkan. Seperti dalam beberapa kasus melewati seluruh array bisa jadi operasi yang mahal. Anda dapat menguji ini dengan meneruskan array ke beberapa fungsi dan membuat beberapa perubahan pada array di sana dan kemudian mencetak array di main lagi. Anda akan mendapatkan hasil yang diperbarui.

Dan seperti yang sudah Anda ketahui, sizeof()fungsi ini memberikan jumlah byte, jadi pada fungsi lain itu akan mengembalikan jumlah byte yang dialokasikan untuk pointer daripada seluruh array. Jadi pendekatan ini tidak berhasil.

Tetapi saya yakin Anda dapat menemukan cara yang baik untuk melakukan ini, sesuai kebutuhan Anda.

Selamat Coding.

Anda memiliki banyak opsi untuk digunakan untuk mendapatkan ukuran array C.

int myArray [] = {0, 1, 2, 3, 4, 5, 7};

1) sizeof(<array>) / sizeof(<type>):

std::cout << "Size:" << sizeof(myArray) / sizeof(int) << std::endl;

2) sizeof(<array>) / sizeof(*<array>):

std::cout << "Size:" << sizeof(myArray) / sizeof(*myArray) << std::endl;

3) sizeof(<array>) / sizeof(<array>[<element>]):

std::cout << "Size:" << sizeof(myArray) / sizeof(myArray[0]) << std::endl;

Ini adalah salah satu implementasi ArraySizedari Google Protobuf .

#define GOOGLE_ARRAYSIZE(a) \
  ((sizeof(a) / sizeof(*(a))) / static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))

// test codes...
char* ptr[] = { "you", "are", "here" };
int testarr[] = {1, 2, 3, 4};
cout << GOOGLE_ARRAYSIZE(testarr) << endl;
cout << GOOGLE_ARRAYSIZE(ptr) << endl;

ARRAYSIZE (arr) bekerja dengan memeriksa sizeof (arr) (# byte dalam array) dan sizeof (* (arr)) (# byte dalam satu elemen array). Jika yang pertama dapat dibagi oleh yang terakhir, mungkin arr memang array, dalam hal ini hasil pembagian adalah # elemen dalam array. Kalau tidak, arr tidak mungkin berupa array, dan kami menghasilkan kesalahan kompiler untuk mencegah kode dari kompilasi.

Karena ukuran bool adalah implementasi yang ditentukan, kita perlu membuang! (Sizeof (a) & sizeof (* (a))) ke size_t untuk memastikan hasil akhir memiliki tipe size_t.

Makro ini tidak sempurna karena salah menerima pointer tertentu, yaitu di mana ukuran pointer dibagi dengan ukuran pointee. Karena semua kode kita harus melalui compiler 32-bit, di mana pointer adalah 4 byte, ini berarti semua pointer ke tipe yang ukurannya 3 atau lebih besar dari 4 akan (dengan benar) ditolak.

Untuk C ++ / CX (saat menulis misalnya aplikasi UWP menggunakan C ++ di Visual Studio) kita dapat menemukan jumlah nilai dalam array dengan hanya menggunakan size()fungsi.

Kode sumber:

string myArray[] = { "Example1", "Example2", "Example3", "Example4" };
int size_of_array=size(myArray);

Jika Anda coutyang size_of_arrayoutput akan:

>>> 4

sizeof(array_name)memberikan ukuran seluruh array dan sizeof(int)memberikan ukuran tipe data dari setiap elemen array.

Jadi, membagi ukuran seluruh array dengan ukuran elemen tunggal array memberikan panjang array.

 int array_name[] = {1, 2, 3, 4, 5, 6};
 int length = sizeof(array_name)/sizeof(int);

JAWABAN :

int number_of_elements = sizeof(array)/sizeof(array[0])

PENJELASAN :

Karena kompiler menetapkan potongan ukuran memori tertentu untuk setiap jenis data, dan sebuah array hanyalah sekelompok dari itu, Anda cukup membagi ukuran array dengan ukuran tipe data. Jika saya memiliki array 30 string, sistem saya menyisihkan 24 byte untuk setiap elemen (string) dari array. Pada 30 elemen, itu total 720 byte. 720/24 == 30 elemen. Algoritma kecil dan ketat untuk itu adalah:

int number_of_elements = sizeof(array)/sizeof(array[0]) yang setara dengan

number_of_elements = 720/24

Perhatikan bahwa Anda tidak perlu tahu tipe data array tersebut, meskipun itu tipe data khusus.

Hanya pemikiran, tetapi hanya memutuskan untuk membuat variabel penghitung dan menyimpan ukuran array di posisi [0]. Saya menghapus sebagian besar kode yang saya miliki di fungsi tetapi Anda akan melihat setelah keluar dari loop, prime [0] diberi nilai akhir 'a'. Saya mencoba menggunakan vektor tetapi VS Express 2013 tidak terlalu menyukainya. Perhatikan juga bahwa 'a' dimulai pada satu untuk menghindari penulisan ulang [0] dan ini diinisialisasi pada awal untuk menghindari kesalahan. Saya bukan ahli, hanya berpikir saya akan berbagi.

int prime[] = {0};
int primes(int x, int y){
    using namespace std; int a = 1;
    for (int i = x; i <= y; i++){prime[a] = i; a++; }
    prime[0] = a; return 0;
}

Solusi bagus yang menggunakan obat generik:

template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }

Kemudian cukup panggil arraysize(_Array);untuk mendapatkan panjang array.

Sumber

Untuk kompiler g ++ lama, Anda bisa melakukan ini

template <class T, size_t N>
char (&helper(T (&)[N]))[N];

#define arraysize(array) (sizeof(helper(array)))

int main() {
    int a[10];
    std::cout << arraysize(a) << std::endl;
    return 0;
}

Saya memberikan solusi rumit di sini:

Anda selalu dapat menyimpan lengthdi elemen pertama:

// malloc/new

arr[0] = length;
arr++;

// do anything. 
int len = *(arr-1);

free(--arr); 

Biaya yang harus Anda --arrbayar ketika memohonfree

Anda dapat menemukan panjang Array dengan mengikuti:

int  arr[] = {1, 2, 3, 4, 5, 6}; 
int size = *(&arr + 1) - arr; 
cout << "Number of elements in arr[] is "<< size; 
return 0;

Cukup Anda dapat menggunakan potongan ini:

#include <iostream>
#include <string>
#include <array>

using namespace std;

int main()
{

  array<int,3> values;
  cout << "No. elements in valuea array: " << values.size() << " elements." << endl;
  cout << "sizeof(myints): " << sizeof(values) << endl;

}

dan inilah rujukannya: http://www.cplusplus.com/reference/array/array/size/

Hindari menggunakan tipe bersamaan dengan sizeof, seperti sizeof(array)/sizeof(char) , tiba-tiba menjadi rusak jika Anda mengubah jenis array.

Di studio visual, Anda memiliki keseimbangan jika sizeof(array)/sizeof(*array). Anda cukup mengetik_countof(array)

Saya pribadi menyarankan (jika Anda tidak dapat bekerja dengan fungsi khusus untuk alasan apa pun) untuk pertama-tama memperluas kompatibilitas tipe array melewati apa yang biasanya Anda gunakan sebagai (jika Anda menyimpan nilai ≥ 0:

unsigned int x[] -> int x[]

daripada Anda akan membuat elemen array 1 lebih besar dari yang Anda butuhkan untuk membuatnya. Untuk elemen terakhir Anda akan meletakkan beberapa tipe yang termasuk dalam specifier tipe diperluas tetapi Anda biasanya tidak menggunakan misalnya menggunakan contoh sebelumnya elemen terakhir adalah -1. Ini memungkinkan Anda (dengan menggunakan for for loop) untuk menemukan elemen terakhir dari sebuah array.

Salah satu alasan paling umum Anda akhirnya mencari ini adalah karena Anda ingin meneruskan array ke suatu fungsi, dan tidak harus melewati argumen lain untuk ukurannya. Anda juga umumnya ingin ukuran array menjadi dinamis. Array itu mungkin berisi objek, bukan primitif, dan objek mungkin rumit sehingga size_of () adalah opsi yang tidak aman untuk menghitung hitungan.

Seperti yang disarankan orang lain, pertimbangkan untuk menggunakan std :: vector atau list, dll sebagai ganti dari array primitif. Pada kompiler lama, bagaimanapun, Anda masih tidak akan memiliki solusi akhir yang mungkin Anda inginkan hanya dengan melakukan itu, karena mengisi wadah membutuhkan banyak baris push_back () jelek. Jika Anda seperti saya, ingin solusi garis tunggal dengan objek anonim terlibat.

Jika Anda menggunakan alternatif wadah STL ke array primitif, pos SO ini mungkin berguna bagi Anda untuk cara menginisialisasi: Apa cara termudah untuk menginisialisasi std :: vektor dengan elemen hardcoded?

Berikut adalah metode yang saya gunakan untuk ini yang akan bekerja secara universal di seluruh kompiler dan platform:

Buat struct atau kelas sebagai wadah untuk koleksi objek Anda. Tetapkan fungsi kelebihan operator untuk <<.

class MyObject;

struct MyObjectList
{
    std::list<MyObject> objects;
    MyObjectList& operator<<( const MyObject o )
    { 
        objects.push_back( o );
        return *this; 
    }
};

Anda dapat membuat fungsi yang menggunakan struct Anda sebagai parameter, misalnya:

someFunc( MyObjectList &objects );

Kemudian, Anda dapat memanggil fungsi itu, seperti ini:

someFunc( MyObjectList() << MyObject(1) <<  MyObject(2) <<  MyObject(3) );

Dengan begitu, Anda dapat membangun dan meneruskan koleksi objek berukuran dinamis ke fungsi dalam satu baris bersih!

Katakanlah Anda memiliki array global yang dideklarasikan di bagian atas halaman

int global[] = { 1, 2, 3, 4 };

Untuk mengetahui berapa banyak elemen yang ada (dalam c ++) dalam array ketik kode berikut:

sizeof(global) / 4;

Sizeof (NAME_OF_ARRAY) / 4 akan memberi Anda jumlah elemen untuk nama array yang diberikan.