Există o modalitate de a găsi cât mai multe valori ale unei matrice are? Detectează dacă sunt sau nu'am ajuns la capat de o matrice ar lucra, de asemenea.
Daca te referi la un C-stil matrice, atunci puteți face ceva de genul:
int a[7];
std::cout << "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl;
Asta nu't de lucru pe indicii, deși, și anume a câștigat't de lucru pentru oricare dintre următoarele:
int *p = new int[7];
std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;
sau:
void func(int *p)
{
std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl;
}
int a[7];
func(a);
În C++, dacă doriți acest tip de comportament, atunci ar trebui să fie folosind o clasă container; probabil std::vector
.
Ca alte's a spus puteți utiliza sizeof(arr)/sizeof(*arr)
dar acest lucru vă va oferi un răspuns greșit pentru indicatorul de tipuri care nu sunt't tablouri.
template<class T, size_t N>
constexpr size_t size(T (&)[N]) { return N; }
Acest lucru are o proprietate frumos de faptul că nu a compila pentru non matrice tipuri (visual studio a _countof
care face acest lucru). A constexpr
face acest lucru o compilare de exprimare, așa că nici't au orice dezavantaje de-a lungul macro (cel puțin nu știu eu).
Puteți, de asemenea, ia în considerare utilizarea std::array
de la C++11, care expune lungimea sa cu nr aeriene peste un nativ C matrice.
C++17 a std::size()
în `
există o modalitate de a găsi cât mai multe valori ale unei matrice are?
Da!
Încerca sizeof(matrice)/sizeof(vector[0])
Detectarea dacă sunt sau nu'am ajuns la capat de o matrice ar lucra, de asemenea.
Nu vad nici un fel pentru acest lucru cu excepția cazului în matrice este o matrice de caractere (am.e string).
P. S : In C++ utilizați întotdeauna std::vector
. Există mai multe incorporat funcții și o funcționalitate extinsă.
În timp ce aceasta este o întrebare veche, l's valoare de actualizarea răspunsul la C++17. În biblioteca standard este acum templated funcția std::size()
, care returnează numărul de elemente din ambele un std container sau un C-stil matrice. De exemplu:
#include <iterator>
uint32_t data[] = {10, 20, 30, 40};
auto dataSize = std::size(data);
// dataSize == 4
Deoarece C++11, un nou template-uri sunt introduse pentru a ajuta la reducerea durerii atunci când se ocupă cu matrice de lungime. Toate acestea sunt definite în header <type_traits>
.
Dacă T este o matrice de tip, oferă statelor valoare constantă egală cu numărul de dimensiuni ale array. Pentru orice alt tip, valoarea este 0.
Dacă T este o matrice de tip, oferă statelor valoare constantă egală cu numărul de elemente de-a lungul N 'th dimensiunea de matrice, dacă" N " este de în [0,
std::rang
Dacă T este o matrice de tip "X", oferă statelor typedef tip egal cu "X", în caz contrar este de tip "T". Rețineți că, dacă T este o matrice multidimensionale, numai prima dimensiune este eliminat.
Dacă T este o matrice multidimensionale de un anumit tip "X", oferă statelor typedef tip egal cu "X", în caz contrar este de tip "T".
Pentru a obține lungimea pe orice dimensiune de un multidimential matrice, decltype
ar putea fi folosite pentru a combina cu std::măsura`. De exemplu:
#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, pentru a obține numărul total de elemente într-un multidimentional matrice:
constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents<decltype(a)>::type);
Sau pune-l într-o funcție șablon:
#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;
}
Mai multe exemple de cum să le folosească putea fi găsite urmând link-uri.
Nu's, de asemenea, TR1/C++11/C++17 mod (vezi Live la 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
În loc de a folosi construit în funcție de matrice aka:
int x[2] = {0,1,2};
ar trebui să utilizați clasa matrice și matrice șablon. Încercați:
#include <array>
array<type_of_the_array, number_of_elements_in_the_array> Name_of_Array = {};
deci, acum, dacă doriți să găsiți lungimea de matrice trebuie doar să utilizați funcția dimensiunea în clasa matrice.
Name_of_Array.size();
și că ar trebui să se întoarcă lungime de elemente în matrice.
În C++, folosind std::clasa matrice pentru a declara o matrice, se poate găsi cu ușurință dimensiunea unei matrice și, de asemenea, ultimul element.
#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;
}
În fapt, clasa matrice are o mulțime de alte funcții care să ne folosim array-un container standard. Referință 1 la C++ std::clasa matrice Referință 2 std::clasa matrice Exemplele din referințe sunt de ajutor.
Aici este o aplicare a ArraySize
de la 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) funcționează prin inspectarea sizeof(arr) (#de octeți în array) și sizeof(*(arr)) (#de octeți într-o singură matrice element). Dacă prima este divizibil cu acesta din urmă, poate arr este într-adevăr, o matrice, în cazul în care divizia rezultatul este # de elemente din matrice. În caz contrar, arr nu poate fi, eventual, o matrice, și vom genera o eroare de compilator pentru a preveni codul de compilarea.
Deoarece dimensiunea de bool este punerea în aplicare definite, avem nevoie pentru a arunca !(sizeof(o) & sizeof(*(a))) a size_t în scopul de a asigura final rezultatul a de tip size_t.
Acest macro nu este perfect, deoarece pe nedrept acceptă anumite indicatori, și anume în cazul în care dimensiunea indicatorului este divizibil cu pointee dimensiune. Deoarece tot codul nostru trebuie să treacă printr-un 32-bit compiler, în cazul în care un pointer este de 4 bytes, acest lucru înseamnă că toate pointeri la un tip al cărui dimensiunea este de 3 sau mai mare decât 4 va fi (neprihănire) a respins.
Pentru C++/CX (atunci când scrieți de exemplu, UWP aplicații folosind C++ în Visual Studio) putem găsi numărul de valori într-o matrice de simplu, cu ajutorul `size () funcția.
Codul Sursă:
string myArray[] = { "Example1", "Example2", "Example3", "Example4" };
int size_of_array=size(myArray);
Dacă tu cout
a size_of_array
de ieșire va fi:
>>> 4
Ai o grămadă de opțiuni pentru a fi utilizate pentru a obține o matrice C de dimensiune.
int myArray[] = {0, 1, 2, 3, 4, 5, 7};
1) sizeof(<matrice>) / sizeof(<formă>):
std::cout << "Size:" << sizeof(myArray) / sizeof(int) << std::endl;
2) sizeof(<matrice>) / sizeof(*<matrice>):
std::cout << "Size:" << sizeof(myArray) / sizeof(*myArray) << std::endl;
3) sizeof(<matrice>) / sizeof(<matrice>[<element>]):
std::cout << "Size:" << sizeof(myArray) / sizeof(myArray[0]) << std::endl;
Pentru vechiul g++ compiler, puteți face acest lucru
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;
}
Pur și simplu puteți folosi acest fragment:
#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;
}
și aici este de referință : http://www.cplusplus.com/reference/array/array/size/
O soluție bună, care utilizează medicamente generice:
template <typename T,unsigned S>
inline unsigned arraysize(const T (&v)[S]) { return S; }
Apoi, pur și simplu apel arraysize(_Array);
pentru a obține lungimea de matrice.