배열의 길이를 확인하려면 어떻게 해야 합니까?

배열의 길이를 확인하려면 어떻게 해야 합니까?

배열에 몇 개의 값이 있는지 찾을 수 있는 방법이 있습니까?배열의 끝에 도달했는지 여부를 감지하는 것도 효과가 있습니다.

C 스타일 배열을 의미한다면 다음과 같은 작업을 수행할 수 있습니다.

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

포인터에서는 작동하지 않습니다(즉, 다음 중 하나에 대해서는 작동하지 않습니다).

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

또는:

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

int a[7];
func(a);

C++에서 이런 동작을 원한다면 컨테이너 클래스를 사용해야 합니다.

다른 사람들이 말했듯이, 당신은 사용할 수 있습니다.sizeof(arr)/sizeof(*arr)은 배열이줄 것입니다 즉, 이 에 는 을 을 이 .

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

이것은 배열이 아닌 유형(Visual Studio는 이렇게 함)에 대해 컴파일에 실패하는 좋은 특성을 가지고 있습니다.는 이것을 컴파일 시간 표현식으로 만들어 매크로(적어도 내가 아는 것은 없음)보다 단점이 없습니다.

사용하는 것도 고려해 볼 수 있습니다.std::arrayC++11에서 기본 C 어레이에 오버헤드 없이 길이를 노출합니다.

C++17이 있습니다.<iterator>동일한 작업을 수행하고 STL 컨테이너에서도 작동하는 헤더(@Jon C 덕분에).

하고있다sizeof myArray해당 배열에 할당된 총 바이트 수를 얻을 수 있습니다.의 한 알수:런음의소로어의소다를수알한다수알를u소런의d음teynn어의gyyfn:rtse로sizeof myArray[0]

그래서, 다음과 같은 것을 얻습니다.

size_t LengthOfArray = sizeof myArray / sizeof myArray[0];

sizeof a를 합니다.size_t, LengthOfArray또한 이러한 유형이 될 것입니다.

이것은 오래된 질문이지만 C++17에 대한 답을 업데이트할 가치가 있습니다.이제 표준 라이브러리에는 std 컨테이너 또는 C-style 배열에 있는 요소의 수를 반환하는 templated 함수가 있습니다.예를 들어,

#include <iterator>

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

배열에 몇 개의 값이 있는지 찾을 수 있는 방법이 있습니까?

네!

해보세요 sizeof(array)/sizeof(array[0])

배열의 끝에 도달했는지 여부를 감지하는 것도 효과가 있습니다.

배열이 문자 배열(즉, 문자열)이 아니면 이를 위한 방법이 없습니다.

P : C P를 합니다.S : C++에서 항상 사용std::vector 기능도. 내장된 기능과 확장된 기능이 몇 가지 있습니다.

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

std::vector방법이 있습니다size()벡터의 원소 개수를 반환합니다.

(네, 이 대답은 혀를 내두르는 대답입니다.)

C++11 이후로 어레이 길이를 다룰 때의 고통을 줄이기 위해 새로운 템플릿이 도입되었습니다. 머리글두에어r에 정의되어 있습니다.<type_traits>.

• std::rank<T>::value

  한다면T는 배열 유형이며, 배열의 차원 수와 같은 멤버 상수 값을 제공합니다.다른 유형의 경우 값은 0입니다.

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

  한다면T는열며을라는의와게다수e게g와sofernelree는열,ys는원라수 N ()인N[0]에 있습니다.std::rank<T>::value). 의 경우 if 다른 유형의 경우T첫 알 수 는그째을라알수는고의첫,고의는sfy수,N값은 0이고 값은 0입니다.

• std::remove_extent<T>::type

  한다면T는 어떤 는떤의다fyes의 배열입니다.X과 을 합니다 을 합니다 과와 같은 멤버X, 은 은 T . T는 다차원 배열이며 첫 번째 차원만 제거됩니다.

• std::remove_all_extents<T>::type

  한다면T는 어떤 의 π π 의 입니다.X과 을 합니다 을 합니다 과와 같은 멤버X, 은 은 T.

배열의 , 의 의 를 를,decltype와될수데다수h될eeddo와데h std::extent를 들어 예를 들어,

#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, 다차원 배열의 전체 요소 수를 구하려면:

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

또는 함수 템플릿에 입력합니다.

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

사용 방법에 대한 더 많은 예는 링크를 참조하면 찾을 수 있습니다.

이것은 꽤 오래되고 전설적인 질문이고 이미 많은 놀라운 대답들이 있습니다.하지만 시간이 지남에 따라 언어에 새로운 기능이 추가되고 있으므로 사용 가능한 새로운 기능에 따라 계속 업데이트해야 합니다.

C++20에 대해 아직 언급하지 않은 사람이 있다는 것을 알게 되었습니다.그래서 답을 쓰려고 생각했습니다.

C++20

C++20에서는 배열의 길이를 찾기 위해 표준 라이브러리에 추가된 새로운 더 나은 방법이 있습니다.std:ssize()는 a. 는 을 합니다 합니다를 합니다.signed value.

#include <iostream>

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

C++17

C++17 에는 이 을 이 을 std::size() 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;
}

추신: 이 방법은 다음에 적합합니다.vector뿐만 아니라.

늙은

이러한 전통적인 접근 방식은 이미 많은 다른 답변에서 언급되고 있습니다.

#include <iostream>

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

참고로 어레이를 다른 기능으로 전달할 때 왜 이 접근 방식이 작동하지 않는지 궁금하다면 참고하세요.이유는,

C++에서 배열은 값으로 전달되지 않고 배열에 대한 포인터가 전달됩니다.일부 경우와 마찬가지로 전체 어레이를 통과하는 것은 비용이 많이 드는 작업이 될 수 있습니다.배열을 어떤 함수에 전달하여 테스트할 수 있으며 배열을 변경한 다음 배열을 메인으로 다시 인쇄할 수 있습니다.결과가 업데이트 될 것입니다.

그리고 당신도 이미 알고 있겠지만,sizeof()함수는 바이트 수를 제공하므로 다른 함수에서는 전체 배열이 아닌 포인터에 할당된 바이트 수를 반환합니다.그래서 이 방법은 효과가 없습니다.

하지만 요구 사항에 따라 이를 수행할 수 있는 좋은 방법을 찾을 수 있으리라 확신합니다.

해피코딩.

TR1/C++11/C++17 방식도 있습니다.

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

내장된 배열 기능을 사용하는 대신,

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

배열 클래스와 배열 템플릿을 사용해야 합니다.시도:

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

이제 배열의 길이를 찾고 싶다면 배열 클래스에서 크기 함수만 사용하면 됩니다.

Name_of_Array.size();

배열에 있는 요소의 길이를 반환해야 합니다.

답변:

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

설명:

컴파일러는 데이터 유형별로 특정 크기의 메모리 청크를 따로 설정하고, 배열은 단순히 그것들의 그룹이기 때문에, 단순히 배열의 크기를 데이터 유형의 크기로 나눈다.문자열이 30개인 배열을 사용할 경우 시스템은 배열의 각 요소( 문자열)에 대해 24바이트를 할당합니다.30개 원소에서 총 720바이트입니다.720/24 == 30개 요소.이를 위한 작고 촘촘한 알고리즘은 다음과 같습니다.

int number_of_elements = sizeof(array)/sizeof(array[0])에 합니다.

number_of_elements = 720/24

사용자 지정 데이터 유형이더라도 배열이 어떤 데이터 유형인지 알 필요는 없습니다.

C++에서는 std::array 클래스를 사용하여 배열을 선언하면 배열의 크기와 마지막 요소를 쉽게 찾을 수 있습니다.

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

---

사실 어레이 클래스에는 표준 컨테이너를 사용할 수 있는 수많은 다른 기능들이 있습니다.
~ C++ class 1 : C++ std ::array class
2 class 2 to std::array class
참고문헌의 예는 도움이 됩니다.

C 배열 크기를 얻기 위해 사용할 수 있는 여러 가지 옵션이 있습니다.

in 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;

sizeof(array_name)체의를다합니다를 나타냅니다.sizeof(int)모든 배열 요소의 데이터 유형 크기를 제공합니다.

따라서 전체 배열의 크기를 배열의 단일 요소의 크기로 나누면 배열의 길이를 얻을 수 있습니다.

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

은 은 의 입니다 입니다 의 은 의ArraySizeGoogle 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;

어레이 크기(arr)는 (arr)의 크기(어레이의 바이트 수)와 (*(arr)의 크기(하나의 어레이 요소의 바이트 수)를 검사하여 작동합니다.전자가 후자로 나뉠 경우 배열이 실제로 존재할 수 있으며, 이 경우 나눗셈 결과는 배열의 원소 수가 됩니다.그렇지 않으면 arr은 배열이 될 수 없으며, 코드가 컴파일되지 않도록 컴파일러 오류를 발생시킵니다.

boole의 크기는 구현이 정의되어 있기 때문에 최종 결과가 size_t가 되도록 size_t에 !(a)의 크기 & size of (*(a)의 크기)를 캐스팅해야 합니다.

이 매크로는 포인터 크기를 포인터 크기로 구분할 수 있는 특정 포인터를 잘못 받아들여서 완벽하지 않습니다.우리의 모든 코드는 포인터가 4바이트인 32비트 컴파일러를 거쳐야 하기 때문에, 이것은 크기가 3이거나 4보다 큰 타입에 대한 모든 포인터가 당연히 거절된다는 것을 의미합니다.

제네릭을 사용하는 좋은 솔루션:

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

그럼 그냥 전화하세요.arraysize(_Array);배열의 길이를 구합니다.

원천

이전 g++ 컴파일러의 경우 이렇게 할 수 있습니다.

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;
}

C++/CX의 경우(글을 쓸 때). Studio의 C은 Visual Studio)의 C++를 수 있습니다.size()기능.

소스 코드:

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

네가 만약cout그size_of_array출력은 다음과 같습니다.

>>> 4

배열의 길이는 다음과 같이 나타낼 수 있습니다.

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

그냥 생각이지만, 카운터 변수를 만들고 배열 크기를 [0] 위치에 저장하기로 결정했습니다.함수에 있던 대부분의 코드를 삭제했지만 루프를 종료하면 prime[0]에 'a'라는 최종 값이 할당됩니다.벡터를 사용해 보았지만 VS Express 2013은 별로 마음에 들지 않았습니다.또한 'a'는 [0]을(를) 덮어쓰지 않기 위해 1에서 시작하고 오류를 방지하기 위해 처음에 초기화됩니다.전 전문가가 아니에요, 그냥 공유하려고요.

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;
}

간단히 이 토막글을 사용할 수 있습니다.

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

}

그리고 여기 참고자료: http://www.cplusplus.com/reference/array/array/size/

동일한 용도로 사용되는 () 연산자의 크기를 사용할 수 있습니다.

샘플 코드 아래 참조

#include <iostream>
using namespace std;
int main() {
  int arr[] = {10,20,30,40,50,60};
  int arrSize = sizeof(arr)/sizeof(arr[0]);
  cout << "The size of the array is: " << arrSize;
  return 0;
}

여기서 까다로운 해결책을 제시합니다.

언제든지 저장할 수 있습니다.length첫번째 요소에서:

// malloc/new

arr[0] = length;
arr++;

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

free(--arr); 

비용은 당신이 해야 한다는 것입니다.--arr를 할 때free

과 와 을 하지 하지 과 을 와 sizeof(array)/sizeof(char) , 의 하면 됩니다 을 됩니다 하면 .

스튜디오에서는 , 은 에서 에서 은 sizeof(array)/sizeof(*array). 간단하게 타이핑할 수 있습니다._countof(array)

함수를 찾는 가장 일반적인 이유 중 하나는 배열을 함수에 전달하고 함수 크기에 대한 다른 인수를 전달할 필요가 없기 때문입니다.또한 일반적으로 배열 크기가 동적인 것이 좋습니다.이 배열에는 프리미티브가 아닌 개체가 포함되어 있을 수 있으며 개체가 복잡하여 size_of()가 카운트를 계산하는 데 안전하지 않은 옵션일 수 있습니다.

다른 사람들이 제안한 것처럼, 프리미티브 배열 대신 std::vector 또는 list 등을 사용하는 것을 고려합니다.그러나 이전 컴파일러에서는 컨테이너를 채우는 데 여러 개의 추한 푸시백() 라인이 필요하기 때문에 단순한 작업으로는 원하는 최종 솔루션을 얻을 수 없습니다.저와 같은 분이라면 익명의 객체가 포함된 단일 라인 솔루션을 원하세요.

기본 배열 대신 STL 컨테이너를 사용하는 경우 이 SO 게시물은 초기화 방법에 유용할 수 있습니다. 하드코딩된 요소로 std::vector를 초기화하는 가장 쉬운 방법은 무엇입니까?

컴파일러와 플랫폼에 걸쳐 범용적으로 작동하는 이 방법은 다음과 같습니다.

객체 모음을 위한 컨테이너로 structor 클래스를 만듭니다.<<에 대한 연산자 오버로드 함수를 정의합니다.

class MyObject;

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

구조를 매개변수로 사용하는 함수를 만들 수 있습니다. 예:

someFunc( MyObjectList &objects );

그런 다음 이 함수를 다음과 같이 호출할 수 있습니다.

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

이렇게 하면 동적으로 크기가 큰 객체 집합을 하나의 깨끗한 선에서 함수로 구축하고 전달할 수 있습니다.

개인적으로 (어떤 이유로든 특수한 기능을 사용할 수 없는 경우) 먼저 일반적으로 사용하는 어레이 유형 호환성을 확장할 것을 제안합니다(값 ≥ 0인 경우).

unsigned int x[] -> int x[]

어레이 1 요소를 필요한 것보다 더 크게 만들 수 있습니다.마지막 요소의 경우 확장된 유형 지정자에 포함되지만 이전 예제를 사용하는 경우 일반적으로 사용하지 않는 유형을 추가합니다. 마지막 요소는 -1입니다.이를 통해 (for loop을 사용하여) 배열의 마지막 요소를 찾을 수 있습니다.

여기 있습니다.

#include <iostream>
using namespace std;

int main() {
 int arr[] = {10,20,30,40,50,60};
 int arrSize = sizeof(arr)/sizeof(arr[0]);
 cout << "The size of the array is: " << arrSize;
return 0;
}

이것이 효과가 있을 것으로 생각합니다.

for(int i=0;array[i];i++)
{
 //do_something
}  

페이지 상단에 전역 배열이 선언되어 있다고 가정합니다.

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

배열에 몇 개의 요소(c++)가 있는지 알아보려면 다음 코드를 입력합니다.

sizeof(global) / 4;

크기 (NAME_OF_)ARY) / 4는 지정된 배열 이름에 대한 요소 수를 반환합니다.

언급URL : https://stackoverflow.com/questions/4108313/how-do-i-find-the-length-of-an-array