for 루프에서 <또는 <=를 사용해야합니다.

루프를 7 번 반복해야한다면 다음을 사용하세요.

for (int i = 0; i < 7; i++)

또는:

for (int i = 0; i <= 6; i++)

두 가지 고려 사항이 있습니다.

• 공연
• 가독성

성능을 위해 Java 또는 C #을 가정합니다. "미만"또는 "작거나 같음"을 사용하는 것이 중요합니까? 다른 언어에 대한 통찰력이있는 경우 어떤 언어를 선택하십시오.

가독성을 위해 0 기반 배열을 가정하고 있습니다.

UPD : 0 기반 배열에 대한 언급이 혼란 스러울 수 있습니다. 배열 요소를 반복하는 것에 대해 말하는 것이 아닙니다. 일반적인 루프입니다.

이 매직 넘버가 무엇인지 설명하는 상수를 사용하는 것에 대한 좋은 점이 아래에 있습니다. 그래서 내가 " int NUMBER_OF_THINGS = 7"를 가졌다면 " i <= NUMBER_OF_THINGS - 1"는 이상하게 보일 것입니다.

첫 번째는 더 관용적 입니다. 특히 반복 횟수를 나타냅니다 (0 기반 의미에서). 1 기반 (예 : JDBC, IIRC)을 사용할 때 <=를 사용하고 싶을 수 있습니다. 그래서:

for (int i=0; i < count; i++) // For 0-based APIs

for (int i=1; i <= count; i++) // For 1-based APIs

실제 코드에서는 성능 차이가 미미할 것으로 예상됩니다.

두 루프 모두 7 번 반복됩니다. 나는 당신이 다른 것에 대한 정말 좋은 이유가 없다면 7이있는 것이 더 읽기 쉽고 명확하다고 말하고 싶습니다.

대학에서 8086 어셈블리를했을 때부터는 다음과 같이하는 것이 더 성능이 좋았던 것을 기억합니다.

for (int i = 6; i > -1; i--)

있었기 때문에 서명이 없으면 점프를 의미 JNS 작업 입니다. 이를 사용하면 비교 값을 얻기 위해 각주기 후에 메모리 조회가없고 비교도 수행되지 않습니다. 요즘 대부분의 컴파일러는 레지스터 사용을 최적화하므로 메모리가 더 이상 중요하지 않지만 여전히 불필요한 비교를 얻을 수 있습니다.

그건 그렇고 당신의 루프에 7이나 6을 넣는 것은 " 매직 넘버 "를 도입하는 것 입니다. 가독성을 높이려면 Intent Revealing Name과 함께 상수를 사용해야합니다. 이렇게 :

const int NUMBER_OF_CARS = 7;
for (int i = 0; i < NUMBER_OF_CARS; i++)

편집 : 사람들은 어셈블리를 얻지 못하므로 더 완전한 예가 분명히 필요합니다.

(i = 0; i <= 10; i ++)에 대해 수행하는 경우 다음을 수행해야합니다.

    mov esi, 0
loopStartLabel:
                ; Do some stuff
    inc esi
                ; Note cmp command on next line
    cmp esi, 10
    jle exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

for (int i = 10; i> -1; i--)를 수행하면 다음과 같이 벗어날 수 있습니다.

    mov esi, 10
loopStartLabel:
                ; Do some stuff
    dec esi
                ; Note no cmp command on next line
    jns exitLoopLabel
    jmp loopStartLabel
exitLoopLabel:

방금 확인한 결과 Microsoft의 C ++ 컴파일러는이 최적화를 수행하지 않지만 다음과 같은 경우 수행합니다.

for (int i = 10; i >= 0; i--) 

따라서 Microsoft C ++ †를 사용하고 있고 오름차순이나 내림차순이 차이가없는 경우 빠른 루프를 사용하려면 다음을 사용해야합니다.

for (int i = 10; i >= 0; i--)

다음 중 하나가 아닌 :

for (int i = 10; i > -1; i--)
for (int i = 0; i <= 10; i++)

그러나 솔직히 "for (int i = 0; i <= 10; i ++)"의 가독성을 얻는 것이 일반적으로 하나의 프로세서 명령을 누락하는 것보다 훨씬 더 중요합니다.

† 다른 컴파일러는 다른 작업을 수행 할 수 있습니다.

<= array.length-1보다 읽기 쉽기 때문에 항상 <array.length를 사용합니다.

또한 <7이고 0 인덱스로 시작한다는 것을 알고 있다면 숫자가 반복 횟수라는 것은 직관적이어야합니다.

최적화 관점에서 보면 중요하지 않습니다.

코드 스타일 관점에서 보면 <. 이유:

for ( int i = 0; i < array.size(); i++ )

훨씬 더 읽기 쉽습니다.

for ( int i = 0; i <= array.size() -1; i++ )

또한 <는 즉시 반복 횟수를 제공합니다.

<에 대한 또 다른 투표는 실수로 인한 실수를 방지 할 수 있다는 것입니다.

@Chris, .NET에서 비용이 많이 드는 .Length에 대한 귀하의 진술은 사실이 아니며 단순한 유형의 경우 정반대입니다.

int len = somearray.Length;
for(i = 0; i < len; i++)
{
  somearray[i].something();
}

실제로보다 느립니다

for(i = 0; i < somearray.Length; i++)
{
  somearray[i].something();
}

나중은 런타임에 의해 최적화 된 경우입니다. 런타임은 i가 배열에 대한 유효한 인덱스임을 보장 할 수 있으므로 경계 검사가 수행되지 않습니다. 전자의 경우 런타임은 루프 전에 수정되지 않았 음을 보장 할 수 없으며 모든 인덱스 조회에 대해 배열의 경계 검사를 강제합니다.

성능과 관련하여 효과적인 차이는 없습니다. 따라서 해결하려는 문제의 맥락에서 이해하기 쉬운 것을 사용합니다.

나는 선호한다:

for (int i = 0; i < 7; i++)

나는 그것이 "루프를 7 번 반복하는 것"으로 더 쉽게 번역된다고 생각한다.

성능에 미치는 영향에 대해 잘 모르겠습니다. 차이점이 모두 정리 될 것이라고 생각합니다.

Java 1.5에서는 다음을 수행 할 수 있습니다.

for (int i: myArray) {
    ...
}

따라서 어레이 케이스의 경우 걱정할 필요가 없습니다.

성능 차이는 없다고 생각합니다. 두 번째 형식은 확실히 더 읽기 쉽지만 마지막 반복 번호를 찾기 위해 정신적으로 하나를 뺄 필요는 없습니다.

편집 : 다른 사람들이 동의하지 않는 것을 봅니다. 개인적으로 저는 루프 구조에서 실제 인덱스 번호를보고 싶습니다. 아마도 Perl의 0..6구문을 더 연상시키기 때문일 수 (0,1,2,3,4,5,6)있습니다. 7이 표시되면 그 옆에있는 연산자를 확인하여 실제로 인덱스 7에 도달하지 않았는지 확인해야합니다.

대부분의 사람들이 읽을 것이기 때문에 "<7"버전을 사용한다고 말하고 싶습니다. 따라서 사람들이 코드를 훑어 보면 코드를 잘못 해석 할 수 있습니다.

"<"가 "<="보다 빠른지 걱정하지 않고 가독성을 높이십시오.

속도를 높이려면 다음을 고려하십시오.

for (int i = 0; i < this->GetCount(); i++)
{
  // Do something
}

성능을 높이려면 다음과 같이 약간 재정렬 할 수 있습니다.

const int count = this->GetCount();
for (int i = 0; i < count; ++i)
{
  // Do something
}

루프에서 GetCount ()가 제거되고 (모든 루프에서 쿼리되므로) "i ++"가 "++ i"로 변경됩니다.

C ++에서는 !=모든 STL 컨테이너에서 사용할 수있는를 선호합니다 . 모든 STL 컨테이너 이터레이터가 비교할 수없는 것은 아닙니다.

Edsger Dijkstra 는 1982 년에 이에 대한 기사 를 썼습니다. 여기서 그는 lower <= i <upper를 주장합니다.

가장 작은 자연수가 있습니다. b) 및 d)에서와 같이 하한을 제외하면 부자 연수 영역에 언급 된 하한 인 가장 작은 자연수에서 시작하는 하위 시퀀스에 대한 힘이 적용됩니다. 그것은 추악하므로 하한의 경우 a) 및 c)에서와 같이 ≤를 선호합니다. 이제 가장 작은 자연수에서 시작하는 하위 시퀀스를 고려하십시오. 상한을 포함하면 시퀀스가 ​​빈 시퀀스로 축소 될 때 후자가 부자연스러워집니다. 그것은 추악하므로 상한선에 대해 우리는 a) 및 d)에서와 같이 <를 선호합니다. 우리는 규칙 a)가 선호된다는 결론을 내립니다.

첫째, 6 또는 7을 사용하지 마십시오.

사용하기 더 좋음 :

int numberOfDays = 7;
for (int day = 0; day < numberOfDays ; day++){

}

이 경우 사용하는 것보다 낫습니다

for (int day = 0; day <= numberOfDays  - 1; day++){

}

더 나은 (Java / C #) :

for(int day = 0; day < dayArray.Length; i++){

}

그리고 더 나은 (C #)

foreach (int day in days){// day : days in Java

}

역방향 루프는 실제로 더 빠르지 만 (다른 프로그래머가 아니라면) 읽기가 더 어렵 기 때문에 피하는 것이 좋습니다. 특히 C #, Java에서 ...

나는이 경우 7이 의미가 있다고 말하는 군중의 의견에 동의하지만 6이 중요한 경우에는 6 번째 색인까지만 개체에 대해 행동하고 있음을 분명히하고 싶다고 말하고 <=은 6을 더 쉽게 볼 수 있기 때문에 더 좋습니다.

대학으로 돌아와서이 두 연산이 CPU에서 계산 시간이 비슷하다는 것을 기억합니다. 물론 우리는 어셈블리 수준에서 이야기하고 있습니다.

그러나 C # 또는 Java를 사용하는 경우 하나가 다른 것보다 속도가 향상 될 것이라고 생각하지 않습니다. 몇 나노초를 얻는다는 것은 혼동 할 가치가 없습니다.

개인적으로 저는 비즈니스 구현 관점에서 이해하기 쉬운 코드를 작성하고 읽기 쉬운 지 확인합니다.

이것은 "잘못된 코드를 잘못 보이게 만들기" 범주 바로 아래에 있습니다.

Java 또는 C #과 같은 제로 기반 인덱싱 언어에서 사람들은 index < count조건의 변화에 익숙합니다 . 따라서이 사실상의 규칙을 활용하면 하나의 오류가 더 명확 해집니다.

성능과 관련하여 : 메모리 풋 프린트 가치가있는 좋은 컴파일러는 문제가없는 것처럼 렌더링해야합니다.

약간 제쳐두고 .Net에서 배열이나 다른 컬렉션을 반복 할 때

foreach (string item in myarray)
{
    System.Console.WriteLine(item);
}

숫자 for 루프보다 더 읽기 쉽습니다. 물론 이것은 실제 카운터 Int 자체가 루프 코드에서 사용되지 않는다고 가정합니다. 성능 변화가 있는지 모르겠습니다.

i <7을 작성하는 데는 여러 가지 좋은 이유가 있습니다. 7 번 반복되는 루프에 숫자 7이 있으면 좋습니다. 성능은 사실상 동일합니다. 거의 모든 사람들이 i <7을 씁니다. 가독성을 위해 작성하는 경우 모든 사람이 즉시 인식 할 수있는 양식을 사용하십시오.

나는 항상 선호했습니다.

for ( int count = 7 ; count > 0 ; -- count )

<를 사용하는 습관을 들이면 배열을 반복 할 때 사용자와 독자 모두에게 일관성이 있습니다. 모든 사람이 표준 컨벤션을 갖는 것이 더 간단 할 것입니다. 그리고 0 기반 배열이있는 언어를 사용하는 경우 <가 규칙입니다.

이것은 <와 <= 사이의 성능 차이보다 거의 확실히 중요합니다. 먼저 기능과 가독성을 목표로 한 다음 최적화하십시오.

또 다른 참고 사항은 i ++보다는 ++ i를하는 것이 더 낫다는 것입니다. 페치 및 증분은 임시 증분이 필요하고 반입은 필요하지 않기 때문입니다. 정수의 경우 컴파일러는 임시 거리를 최적화 할 수 있지만 반복 유형이 더 복잡하면 불가능할 수 있습니다.

매직 넘버를 사용하지 마십시오.

왜 7입니까? (또는 그 문제에 대해 6).

사용하려는 번호에 올바른 기호를 사용하십시오.

어떤 경우에는 사용하는 것이 더 낫다고 생각합니다

for ( int i = 0; i < array.size(); i++ )

'<'및 '<='연산자는 정확히 동일한 성능 비용입니다.

'<'연산자는 표준이며 0부터 시작하는 루프에서 읽기가 더 쉽습니다.

i ++ 대신 ++ i를 사용하면 C ++에서 성능이 향상되지만 C #에서는 성능이 향상되지 않습니다. Java에 대해 잘 모릅니다.

사람들이 관찰했듯이 언급 한 두 가지 대안 중 어느 것도 차이가 없습니다. 이를 확인하기 위해 JavaScript에서 간단한 벤치마킹을 수행했습니다.

여기 에서 결과를 볼 수 있습니다 . 여기서 명확하지 않은 것은 1 차와 2 차 테스트의 위치를 ​​바꾸면 두 테스트의 결과가 바뀐다는 것입니다. 이것은 분명히 메모리 문제입니다. 그러나 세 번째 테스트, 반복 순서를 반대로하는 테스트는 분명히 더 빠릅니다.

모두가 말했듯이 배열 외부에 대해서도 0 인덱스 반복기를 사용하는 것이 일반적입니다. 모든 것이에서 시작 0하고 끝나고 n-1하한이 항상 <=이고 상한이 항상 <인 경우 코드를 검토 할 때해야 할 생각이 훨씬 적습니다.

좋은 질문입니다. 내 대답 : 유형 A 사용 ( '<')

• 얼마나 많은 반복이 있는지 명확하게 볼 수 있습니다 (7).
• 두 끝점의 차이는 범위의 너비입니다.
• 문자가 적을수록 가독성이 높아집니다.
• 마지막 요소i < strlen(s) 의 색인 보다 총 요소 수가 더 많으 므로 균일 성이 중요합니다.

또 다른 문제는이 전체 구조에 있습니다. 3 번i 표시 되므로 오타가 발생할 수 있습니다. for-loop 구조는 무엇을해야하는지 대신 어떻게해야하는지 말합니다 . 나는 이것을 채택하는 것이 좋습니다.

BOOST_FOREACH(i, IntegerInterval(0,7))

이것은 더 명확하고 동일한 asm 명령어 등을 exaclty하기 위해 컴파일됩니다. 원한다면 IntegerInterval 코드를 요청하십시오.

너무 많은 답변이 있지만 추가 할 것이 있다고 생각합니다.

내가 선호하는 것은 리터럴 숫자가 "i"가 루프에서 취할 값 을 명확하게 보여주는 것 입니다. 따라서 0부터 시작하는 배열을 반복하는 경우 :

for (int i = 0; i <= array.Length - 1; ++i)

그리고 배열을 반복하지 않고 반복하는 경우 1부터 7까지 계산하는 것은 매우 직관적입니다.

for (int i = 1; i <= 7; ++i)

가독성은 프로파일 링 할 때까지 성능을 능가합니다. 그때까지는 컴파일러 나 런타임이 코드로 무엇을할지 모르기 때문입니다.

!=대신 사용할 수도 있습니다 . 이렇게하면 초기화에서 오류가 발생하면 무한 루프가 발생하여 오류가 더 일찍 발견되고 이로 인해 발생하는 모든 문제가 루프에 갇히도록 제한됩니다. 그것).

어느 쪽이든 괜찮다고 생각하지만, 선택하면 둘 중 하나를 고수하십시오. <=을 사용하는 데 익숙하다면 <를 사용하지 말고 그 반대도 마찬가지입니다.

나는 <=를 선호하지만 0에서 시작하는 인덱스로 작업하는 상황에서는 아마도 <를 사용하려고 할 것입니다. 그래도 모두 개인적인 취향입니다.

엄격히 논리적 관점에서 보면 평등을 테스트 하는 정확한 이유 < count보다 더 효율적 이라고 생각해야 합니다.<= count<=