'for'루프에서 1 씩 증가 할 때! = 대신> (<)를 사용해야하는 기술적 이유가 있습니까?

나는 for이런 루프를 거의 보지 못했다 .

for (int i = 0; 5 != i; ++i)
{}

루프 에서 1 씩 증가 할 때 >또는 <대신 사용해야하는 기술적 이유가 있습니까? 아니면 이것은 관습에 더 가깝습니까?!=for

while (time != 6:30pm) {
    Work();
}

오후 6시 31 분입니다 ... 젠장, 이제 집에 갈 다음 기회는 내일입니다! :)

이것은 더 강한 제한이 위험을 완화시키고 이해하기에 더 직관적임을 보여줍니다.

기술적 이유는 없습니다. 그러나 위험, 유지 관리 성 및 코드에 대한 이해가 완화됩니다.

< 또는 >!= 대부분의 경우에 동일한 목적을 달성하는 것보다 더 강한 제한이 있으며 (모든 실제적인 경우에도 말하고 있습니다).

여기에 중복 된 질문이 있습니다 . 그리고 하나의 흥미로운 답변 입니다.

네 이유가 있습니다. 이런 식으로 for 루프를 작성하면 (일반 인덱스 기반)

for (int i = a; i < b; ++i){}

그런 다음 a및의 모든 값에 대해 예상대로 작동합니다 b(예 : a > b무한대 대신에 0 반복 을 사용한 경우i == b; ).

반면에 반복자에 대해서는 다음과 같이 작성하십시오.

for (auto it = begin; it != end; ++it) 

모든 반복자가을 구현해야 operator!=하지만 모든 반복자에 대해 그런 것은 아닙니다.operator< .

범위 기반 for 루프

for (auto e : v)

공상 설탕뿐만 아니라 잘못된 코드를 작성할 가능성을 상당히 줄입니다.

당신은 같은 것을 가질 수 있습니다

for(int i = 0; i<5; ++i){
    ...
    if(...) i++;
    ...
}

내부 변수로 루프 변수를 작성하면 i!=5해당 루프가 중단되지 않을 수 있습니다. 불평등을 확인하는 것이 더 안전합니다.

가독성에 대한 편집 . 불평등 형태가 더 자주 사용됩니다. 따라서 이해해야 할 것이 없기 때문에 읽기 속도가 매우 빠릅니다 (작업이 일반적이므로 브레인로드가 줄어 듭니다). 따라서 독자가 이러한 습관을 활용하는 것이 좋습니다.

마지막으로 이것을 방어 프로그래밍 이라고 합니다 합니다. 이는 프로그램에 영향을 미치는 현재 및 미래의 오류를 피하기 위해 항상 가장 강력한 사례를 취하는 것을 의미합니다.

방어 프로그래밍이 필요하지 않은 유일한 경우는 상태가 사전 및 사후 조건에 의해 입증 된 경우입니다 (그러나 이것이 모든 프로그래밍 중 가장 방어적임을 증명).

나는 같은 표현이

for ( int i = 0 ; i < 100 ; ++i )
{
  ...
}

보다 의도를 더 표현한다

for ( int i = 0 ; i != 100 ; ++i )
{
  ...
}

전자는 조건이 범위에 대한 독점 상한에 대한 테스트임을 분명히 지적합니다. 후자는 종료 조건의 이진 테스트입니다. 그리고 루프의 본문이 사소한 것이 아니라면, 인덱스 for자체 가 명령문 에서만 수정 된 것은 분명하지 않을 수 있습니다.

반복자는 !=표기법 을 가장 자주 사용할 때 중요한 경우입니다 .

for(auto it = vector.begin(); it != vector.end(); ++it) {
 // do stuff
}

부여 : 실제로는 range-for:에 의존하는 동일한 내용을 작성합니다 .

for(auto & item : vector) {
 // do stuff
}

하지만 요점은 남아있다 : 하나는 일반적으로 사용하는 반복자를 비교 ==하거나 !=.

루프 조건은 강제 루프 불변입니다.

루프의 본문을 보지 않는다고 가정하십시오.

for (int i = 0; i != 5; ++i)
{
  // ?
}

이 경우 루프 반복이 시작될 때 i같지 않은 것을 알 수 5있습니다.

for (int i = 0; i < 5; ++i)
{
  // ?
}

이 경우 루프 반복 시작시 i보다 작은 것을 알 수 5있습니다.

두 번째는 첫 번째보다 훨씬 더 많은 정보입니다. 이제 프로그래머의 의도는 (거의 확실합니다) 동일하지만 버그를 찾고 있다면 코드 줄을 읽는 것에 대한 확신을 갖는 것이 좋습니다. 그리고 두 번째 는 불변성을 강제 합니다. 이는 첫 번째 경우에 물린 버그가 두 번째 경우에는 발생할 수 없거나 메모리 손상을 유발하지 않습니다.

with <보다 적은 코드를 읽음으로써 프로그램의 상태에 대해 더 많이 알고 있습니다 !=. 최신 CPU에서는 차이가없는 것과 동일한 시간이 걸립니다.

당신이 경우 i루프 본문에서 조작,하지 않은 및 항상 1 씩 증가했다, 그리고 그것은보다 적은 시작5 , 차이가 없을 것이다. 그러나 그것이 조작되었는지 알기 위해서는 이러한 각 사실을 확인해야합니다.

이러한 사실 중 일부는 비교적 쉽지만 잘못 될 수 있습니다. 그러나 루프 전체를 점검하는 것은 고통입니다.

C ++에서는 다음 indexes과 같은 유형을 작성할 수 있습니다 .

for( const int i : indexes(0, 5) )
{
  // ?
}

위의 두 for루프 중 하나와 동일한 작업 을 수행하며 컴파일러까지 동일한 코드로 최적화합니다. 그러나 여기, 당신은 알고 그 i가 선언되는 한, 루프의 본문에 조작 할 수없는 const코드 손상 메모리없이.

컨텍스트를 이해하지 않고 코드 라인에서 얻을 수있는 정보가 많을수록 문제를 쉽게 추적 할 수 있습니다. <정수 루프의 경우 해당 줄의 코드 상태에 대한 정보를 제공합니다 !=.

예; OpenMP는 루프를 !=조건 과 병렬화하지 않습니다 .

변수 i가 큰 값으로 설정 되었을 수 있으며 !=연산자를 사용 하면 무한 루프로 끝납니다.

다른 많은 답변에서 볼 수 있듯이! = 대신 <를 사용해야하는 이유가 있습니다.

솔직히, 나는 당신이 컨벤션의 중요성을 충분히 강조 할 수 있다고 생각하지 않습니다. 이 예제에서는 다른 프로그래머가 수행하려는 작업을 쉽게 알 수 있지만 두 번 수행 할 수 있습니다. 프로그래밍하는 동안 작업 중 하나는 모든 사람이 읽을 수 있고 친숙하게 만들 수 있기 때문에 누군가가 코드를 업데이트 / 변경해야 할 때 필연적으로 다른 코드 블록에서 수행중인 작업을 파악하는 데 많은 노력을 기울이지 않습니다. . 누군가가을 사용하는 것을 보았을 때 !=, 그들이 대신 사용하는 이유가 있다고 가정 <했을 것입니다. 큰 루프 인 경우 필요한 것을 만든 것을 알아 내려고하는 모든 것을 살펴볼 것입니다 ... 낭비 된 시간.

Ian Newson이 이미 말했듯이 부동 변수를 안정적으로 반복하고로 종료 할 수는 없습니다 !=. 예를 들어

for (double x=0; x!=1; x+=0.1) {}

0.1은 부동 소수점으로 정확하게 표현 될 수 없으므로 카운터는 1을 잃어 버립니다 <.

(그러나 0.9999 ...를 마지막으로 받아 들여진 숫자로 가정하거나 (이는 가정을 위반 한 경우) 이미 1.0000000000000001에서 종료하는지 여부는 기본적으로 정의되지 않은 동작 입니다.)

나는 형용사 "기술적"을 사용하여 생성 된 코드의 성능과 같은 언어 행동 / 질투 및 컴파일러 부작용을 의미합니다.

이를위한 대답은 no (*)입니다. (*)는 "프로세서 설명서를 참조하십시오". 일부 첨단 RISC 또는 FPGA 시스템으로 작업하는 경우 생성되는 명령어와 비용을 확인해야합니다. 당신은 거의 모든 기존의 현대 건축을 사용하는 경우, 그때가 사이의 비용 유의 프로세서 수준의 차이는 없다 lt, eq, ne와 gt.

경우 당신이 가장자리 케이스를 사용하는 당신은 찾을 수있는 !=세 가지 작업 (요구 cmp, not, beq(두 대)를 cmp,blt xtr myo ). 이 경우에도 RTM입니다.

대부분의 경우, 특히 포인터 나 복잡한 루프로 작업 할 때 방어 / 경화가 발생합니다. 치다

// highly contrived example
size_t count_chars(char c, const char* str, size_t len) {
    size_t count = 0;
    bool quoted = false;
    const char* p = str;
    while (p != str + len) {
        if (*p == '"') {
            quote = !quote;
            ++p;
        }
        if (*(p++) == c && !quoted)
            ++count;
    }
    return count;
}

덜 귀중한 예는 반환 값을 사용하여 증분을 수행하고 사용자의 데이터를 수락하는 경우입니다.

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i != len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;

        std::cin >> step;
        i += step; // here for emphasis, it could go in the for(;;)
    }
}

이것을 시도하고 값 1, 2, 10, 999를 입력하십시오.

이것을 막을 수 있습니다 :

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i != len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;
        std::cin >> step;
        if (step + i > len)
            std::cout << "too much.\n";
        else
            i += step;
    }
}

그러나 아마도 당신이 원했던 것은

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i < len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;
        std::cin >> step;
        i += step;
    }
}

이 향해 컨벤션 바이어스의 무언가는 또한 <표준 컨테이너의 순서는 종종에 의존하기 때문에, operator<여러 STL 컨테이너에 인스턴스 해싱을 위해, 말함으로써 평등을 결정한다

if (lhs < rhs) // T.operator <
    lessthan
else if (rhs < lhs) // T.operator < again
    greaterthan
else
    equal

만약 lhs및 rhs사용자 정의 클래스는이 코드 등을 작성하는

if (lhs < rhs) // requires T.operator<
    lessthan
else if (lhs > rhs) // requires T.operator>
    greaterthan
else
    equal

구현자는 두 가지 비교 기능을 제공해야합니다. 따라서 <선호하는 운영자가되었습니다.

모든 종류의 코드를 작성하는 방법은 여러 가지가 있으며 (보통)이 경우에는 두 가지 방법이 있습니다 (<= 및> =를 세면 세 가지).

이 경우 사람들은>와 <을 선호하여 루프에서 예기치 않은 일이 발생하더라도 (버그처럼) 무한 반복 (BAD)하지 않도록합니다. 예를 들어 다음 코드를 고려하십시오.

for (int i = 1; i != 3; i++) {
    //More Code
    i = 5; //OOPS! MISTAKE!
    //More Code
}

(i <3)을 사용하면 더 큰 제한을두기 때문에 무한 루프로부터 안전합니다.

프로그램의 실수로 모든 것을 종료하거나 버그로 계속 작동하는지 여부는 실제로 선택합니다.

이것이 도움이 되었기를 바랍니다!

가장 일반적인 이유 < 는 규칙입니다. 더 많은 프로그래머들은 "인덱스가 끝날 때까지"가 아니라 "인덱스가 범위 내에있는 동안"이와 같은 루프를 생각합니다. 당신이 할 수있는 가치는 관습에 충실합니다.

다른 한편으로, 여기에 많은 답변은 <양식 을 사용하면 버그를 피하는 데 도움 이된다고 주장합니다 . 많은 경우 이것이 버그를 숨기는 데 도움이된다고 주장합니다 . 루프 인덱스가 최종 값에 도달해야하고 실제로 그 값을 초과하면 오작동 (또는 다른 버그의 부작용)을 유발할 수있는 예상치 못한 일이 발생합니다. 는 <가능성이 버그의 발견을 지연됩니다. 는 !=당신이 빨리 버그를 발견하는 데 도움이되는 매점, 중단, 또는 충돌로 이어질 가능성이 높습니다. 버그가 빨리 발견 될수록 더 저렴하게 해결할 수 있습니다.

이 규칙은 배열 및 벡터 인덱싱에 고유합니다. 거의 모든 다른 유형의 데이터 구조를 탐색 할 때는 반복자 (또는 포인터)를 사용하고 종료 값을 직접 확인해야합니다. 이러한 경우 반복자가 실제 최종 값에 도달하고이를 초과하지 않도록해야합니다.

예를 들어, 일반 C 문자열을 단계별로 실행하는 경우 일반적으로 다음과 같이 작성하는 것이 더 일반적입니다.

for (char *p = foo; *p != '\0'; ++p) {
  // do something with *p
}

...보다

int length = strlen(foo);
for (int i = 0; i < length; ++i) {
  // do something with foo[i]
}

우선, 문자열이 매우 길면 두 번째 형식이 strlen문자열을 통과하는 다른 형식이기 때문에 속도가 느려집니다 .

C ++ std :: string을 사용하면 길이를 쉽게 사용할 수 있어도 범위 기반 for 루프, 표준 알고리즘 또는 반복자를 사용합니다. 반복자를 사용 !=하는 경우 다음 <과 같이 규칙 대신 을 사용하는 것이 좋습니다 .

for (auto it = foo.begin(); it != foo.end(); ++it) { ... }

마찬가지로 트리 나 목록 또는 deque를 반복하면 일반적으로 인덱스가 범위 내에 있는지 확인하는 대신 null 포인터 나 다른 센티넬을 감시해야합니다.

이 구문을 사용하지 않는 한 가지 이유는 부동 소수점 숫자입니다. !=숫자가 동일하게 보이더라도 거의 참으로 평가되지 않으므로 float와 함께 사용하는 것은 매우 위험한 비교입니다. <또는 >이 위험을 제거합니다.

이 연습을 따르는 데는 두 가지 관련 이유가 있습니다. 프로그래밍 언어는 결국 사람이 읽을 수있는 언어라는 사실과 관련이 있습니다.

(1) 약간의 중복성. 자연어에서는 일반적으로 오류 수정 코드와 매우 유사하게 필요한 것보다 더 많은 정보를 제공합니다. 여기에 추가 정보는 루프 변수입니다 i(여기에서 중복성을 어떻게 사용했는지 참조하십시오. '루프 변수'의 의미를 모르거나 변수 이름을 잊어 버린 경우 "루프 변수 i"를 읽은 후 5)와 다르지 않고 루프 동안 정보가 5보다 작습니다. 중복성은 가독성을 향상시킵니다.

(2) 협약. 언어에는 특정 상황을 표현하는 특정 표준 방법이 있습니다. 당신이 어떤 말을하는 기존의 방식을 따르지 않는다면, 당신은 여전히 ​​이해 될 것이지만, 특정 최적화가 작동하지 않기 때문에 메시지를받는 사람을위한 노력은 더 커집니다. 예:

핫 매쉬에 대해 이야기하지 마십시오. 어려움을 밝히십시오!

첫 번째 문장은 독일 관용구의 문자 번역입니다. 두 번째는 일반적인 영어 관용구이며 주요 단어가 동의어로 대체되었습니다. 결과는 이해할 수 있지만 이것보다 이해하는 데 많은 시간이 걸립니다.

덤불을 두드리지 마십시오. 문제를 설명해주세요!

첫 번째 버전에서 사용 된 동의어가 영어 관용구의 기존 단어보다 상황에 더 잘 맞는 경우에도 마찬가지입니다. 프로그래머가 코드를 읽을 때 비슷한 힘이 적용됩니다. 이 이유도 5 != i하고 5 > i퍼팅의 이상한 방법입니다 하지 않는 한 당신이 더 정상적인 교환 표준 인 환경에서 작업 i != 5하고 i < 5이런 식으로는. 일관성이 5 == i자연 스럽지만 오류가 발생하기 쉬운 쓰기 보다는 기억하기 쉽기 때문에 그러한 방언 커뮤니티가 존재합니다 i == 5.

이러한 경우 관계 비교를 사용하는 것이 다른 무엇보다 인기있는 습관입니다. 그것은 반복자 범주와 같은 개념적 고려 사항과 그 비교 가능성이 우선 순위로 고려되지 않은 시대에 인기를 얻었습니다.

평등 비교는 비교되는 값에 대한 요구 사항이 적기 때문에 가능하면 관계 비교 대신 평등 비교를 사용하는 것이 좋습니다. 존재 EqualityComparable로는 것보다 낮은 요구 사항입니다 LessThanComparable을 .

이러한 맥락에서 평등 비교의 더 넓은 적용 가능성을 보여주는 또 다른 예는 unsigned반복을 아래로 구현하는 인기있는 수수께끼입니다 0. 다음과 같이 할 수 있습니다

for (unsigned i = 42; i != -1; --i)
  ...

위의 내용은 부호있는 반복과 부호없는 반복 모두에 동일하게 적용되는 반면 관계형 버전은 부호없는 유형으로 분류됩니다.

루프 변수가 (의도적이지 않은) 차체 내부에서 변경되는 예제 외에도 작거나 큰 연산자를 사용하는 다른 방법이 있습니다.

• 부정은 코드를 이해하기 어렵게 만듭니다
• <또는 >하나의 문자이지만 !=두 개

위험을 완화한다고 언급 한 다양한 사람들 외에도 다양한 표준 라이브러리 구성 요소와 상호 작용하는 데 필요한 기능 과부하 수를 줄입니다. 예를 들어, 형식을에 저장 std::set하거나 키로 std::map사용하거나 일부 검색 및 정렬 알고리즘과 함께 사용 std::less하려는 경우 표준 라이브러리는 일반적 으로 대부분의 알고리즘이 엄격한 약한 순서 만 필요하므로 개체를 비교하는 데 사용 합니다 . 따라서 비교 (물론 의미가있는 경우) <대신 비교 를 사용하는 것이 좋습니다 !=.

구문 관점에서 문제는 없지만 그 표현의 논리 5!=i는 건전하지 않습니다.

내 의견 !=으로는 for 루프의 경계를 설정하는 데 사용 하는 것이 논리적으로 건전하지 않습니다 .for 루프는 반복 색인을 늘리거나 줄이므로 반복 색인이 경계를 벗어날 때까지 루프를 반복하도록 설정하십시오 (!= 것은 아닙니다. 적절한 구현.

그것은 작동하지만 사용할 때 경계 데이터 처리가 손실되기 때문에 그것이 잘못된 행동하는 경향이 !=증가 문제에 대한 (당신은 처음부터 알고 있다는 것을 의미 경우 증가하거나 감소) 대신 이유, !=(가) <>>==>사용됩니다.