ฉันจะสละชื่อตัวแปรที่สั้นลงสำหรับรหัส“ columned” ที่ยาวขึ้นหรือไม่

ฉันเป็นนักเขียนโปรแกรมสมัครเล่นในชั้นเรียน CS ที่พยายามเรียนรู้ทักษะการเขียนโปรแกรมที่เหมาะสม นี่คือลักษณะของรหัสของฉันขอบของมันขยายไปถึง 103 คอลัมน์

int extractMessage(char keyWord[25], char cipherText[17424],
                   int rowSize, char message[388]) 
{
    int keyColumn    = 0;
    int cipherColumn = 0;
    int offset       = 1;
    int nextWord     = 1;

    int lengthOfWord   = 0;
    int lengthOfCipher = 0;

    lengthOfWord = length(keyWord);
    lengthOfCipher = length(cipherText);


    while (keyWord[keyColumn] != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyWord[keyColumn + offset] != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
            cipherColumn++;
            continue;
        }
    }

ก่อนที่ฉันจะมีชื่อตัวแปรที่ยาวมากฉันมีสิ่งต่าง ๆ เช่น i, j, k แต่อาจารย์ของฉันยืนยันว่าเราจะไม่ใช้ตัวแปรเช่นนั้นใน "โลกมืออาชีพ" และแม้แต่ตัวแปรที่สั้นลงเช่น lenWord ก็ไม่เพียงพอเพราะผู้คนอาจคิดว่า มันหมายถึง "วรรณกรรมของโลกเลนนาร์ด" เขาบอกว่าจะเลือกชื่อตัวแปรที่มีความหมาย แต่โดยการทำเช่นนั้นฉันรู้สึกเหมือนว่าฉันได้ทำลายกฎทองของการเข้ารหัสเพื่อให้อยู่ภายใต้คอลัมน์ 80 คอลัมน์ ฉันจะรับสิ่งนี้ได้อย่างไร

โดยปกติเมื่อฉันเห็นรหัสที่โพสต์ที่นี่เช่นคุณฉันแก้ไขเพราะเราเกลียดการเลื่อนในแนวนอน แต่เนื่องจากเป็นส่วนหนึ่งของคำถามของคุณฉันจะแสดงการแก้ไขที่นี่:

int extractMessage(char keyWord[25], char cipherText[17424],
                   int rowSize, char message[388]) 
{
    int keyColumn    = 0;
    int cipherColumn = 0;
    int offset       = 1;
    int nextWord     = 1;

    int lengthOfWord   = 0;
    int lengthOfCipher = 0;

    lengthOfWord = length(keyWord);
    lengthOfCipher = length(cipherText);


    while (keyWord[keyColumn] != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyWord[keyColumn + offset] 
        != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
            cipherColumn++;
            continue;
        }
    }
}

แบ่งนั่นอาจจะเป็นที่น่าแปลกใจ แต่ก็อ่านได้มากขึ้นกว่ารุ่นที่มีเลื่อนแนวนอนและจะดีกว่าการตัดทอนชื่อเพื่อi, และjk

มันไม่ใช่ว่าคุณไม่ควรใช้i, และj kเหล่านี้เป็นชื่อที่ดีเมื่อทำดัชนีforลูปซ้อนกัน 3 รายการ แต่ที่นี่ชื่อเป็นเบาะแสเดียวของฉันเกี่ยวกับสิ่งที่คุณคาดว่าจะเกิดขึ้น โดยเฉพาะอย่างยิ่งเนื่องจากรหัสนี้ไม่ได้ทำอะไรเลย

กฎที่ดีที่สุดที่จะติดตามความยาวชื่อตัวแปรคือขอบเขต ยิ่งตัวแปรมีอายุการใช้งานนานเท่าไหร่ตัวแปรที่ยิ่งใหญ่กว่าชื่อของมันก็จะต้องแข่งขันกัน ชื่อCandiedOrangeไม่ซ้ำกันในการแลกเปลี่ยนสแต็ค ถ้าเราอยู่ในการแชทคุณอาจเรียกฉันว่า "แคนดี้" แต่ตอนนี้คุณอยู่ในขอบเขตที่ชื่อที่อาจจะสับสนกับCandide , ขนมหวานชิวหรือCandyfloss ดังนั้นขอบเขตที่ยาวขึ้นชื่อก็ควรจะยาวขึ้น ขอบเขตที่สั้นลงชื่อที่สั้นกว่าก็จะเป็นได้

ความยาวบรรทัดไม่ควรกำหนดความยาวชื่อ หากคุณรู้สึกว่ามันเป็นวิธีที่แตกต่างกันในการวางรหัสของคุณ เรามีเครื่องมือมากมายที่จะช่วยคุณทำเช่นนั้น

หนึ่งในสิ่งแรกที่ฉันมองหาคือเสียงที่ไม่จำเป็นในการกำจัด น่าเสียดายที่ตัวอย่างนี้ไม่ได้ทำอะไรเลยมันเป็นเสียงที่ไม่จำเป็น ฉันต้องการบางสิ่งบางอย่างเพื่อทำงานด้วยก่อนอื่นมาทำมันกันเถอะ

int calcCipherColumn(char keyWord[25], char cipherText[17424],
                     int rowSize, char message[388]) 
{
    int keyColumn    = 0;
    int cipherColumn = 0;
    int offset       = 1;
    int nextWord     = 1;

    int lengthOfWord   = 0;
    int lengthOfCipher = 0;

    lengthOfWord = length(keyWord);
    lengthOfCipher = length(cipherText);

    while (keyWord[keyColumn] != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyWord[keyColumn + offset] 
        != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
            cipherColumn++;
            continue;
        }
    }
    return cipherColumn;
}

ตอนนี้มันทำอะไรบางอย่าง

ตอนนี้มันทำอะไรซักอย่างฉันสามารถเห็นสิ่งที่ฉันสามารถกำจัดได้ สิ่งที่ความยาวนี้ไม่ได้ใช้ นี่continueไม่ได้ทำอะไรเลย

int calcCipherColumn(char keyWord[25], char cipherText[17424],
                     int rowSize, char message[388]) 
{
    int keyColumn    = 0;
    int cipherColumn = 0;
    int offset       = 1;
    int nextWord     = 1;

    while (keyWord[keyColumn] != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyWord[keyColumn + offset] 
        != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
            cipherColumn++;
        }
    }
    return cipherColumn;
}

มาทำให้พื้นที่สีขาวเล็ก ๆ น้อย ๆ ปรับเปลี่ยนเพราะเราอยู่ในโลกของการควบคุมแหล่งที่มาและมันก็ดีเมื่อเหตุผลเดียวที่มีการรายงานบรรทัดที่มีการเปลี่ยนแปลงเนื่องจากมันทำสิ่งที่แตกต่างไม่ใช่เพราะส่วนหนึ่งของมันต้องอยู่ในคอลัมน์

int calcCipherColumn(char keyWord[25], char cipherText[17424],
                     int rowSize, char message[388]) 
{
    int keyColumn = 0;
    int cipherColumn = 0;
    int offset = 1;
    int nextWord = 1;

    while (keyWord[keyColumn] != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyWord[keyColumn + offset] 
        != cipherText[cipherColumn + (rowSize*nextWord) + nextWord]) {
            cipherColumn++;
        }
    }
    return cipherColumn;
}

ใช่ฉันรู้ว่ามันอ่านได้น้อยลงเล็กน้อย แต่อย่างอื่นคุณจะทำให้ผู้คนบ้าคลั่งที่ใช้เครื่องมือ vdiff เพื่อตรวจจับการเปลี่ยนแปลง

ทีนี้ลองมาแก้ไขเส้นแบ่งโง่ที่เรามีเพราะเราพยายามอยู่ภายใต้ขีดจำกัดความยาวบรรทัด

int calcCipherColumn(
        char keyWord[25], 
        char cipherText[17424],
        int rowSize, 
        char message[388]
) {
    int keyColumn = 0;
    int keyOffset = 1;

    int nextWord = 1;
    int cipherColumn = 0;
    int cipherOffset = (rowSize * nextWord) + nextWord;

    char key = keyWord[keyColumn];
    char keyNext = keyWord[keyColumn + keyOffset];

    while (key != cipherText[cipherColumn]) {
        cipherColumn++;
        if (keyNext != cipherText[cipherColumn + cipherOffset]) {
            cipherColumn++;
        }
    }
    return cipherColumn;
}

ที่นั่นตอนนี้ตรรกะในลูปจะเน้นไปที่การเปลี่ยนแปลงในลูป อันที่จริงทุกอย่างยกเว้นcipherColumnสามารถทำเครื่องหมายfinalได้ และเฮ้! ดูนั่นสิ ตอนนี้เรามีห้องให้ทำ

ทั้งหมดที่ฉันทำคือเพิ่มตัวแปรอีก 3 ตัวเปลี่ยนชื่อใหม่และจัดเรียงใหม่อีกเล็กน้อย และผลลัพธ์ก็เกิดขึ้นเพื่อทำให้เส้นสั้นพอที่จะให้พอดีโดยไม่ต้องมีการเรียงตัวโง่!=ๆ

แน่ใจว่าชื่อkeyและkeyNextไม่ใช่คำอธิบายนั้น แต่พวกเขาแต่ละคนจะได้ใช้เพียงครั้งเดียวอย่ามีชีวิตอยู่นานขนาดนั้นและที่สำคัญที่สุดคือไม่ได้ทำอะไรที่น่าสนใจในวง ดังนั้นพวกเขาไม่จำเป็นต้องเป็น ด้วยการแนะนำตัวแปรเพิ่มเติมตอนนี้เรามีพื้นที่ที่จะทำให้ชื่อของพวกเขายาวถ้าเราต้องการ สิ่งต่าง ๆ เปลี่ยนแปลงดังนั้นในที่สุดเราอาจจำเป็นต้อง ถ้าเราทำมันดีที่เรามีห้องหายใจ

ฉันใช้เสรีภาพในการแสดงรูปแบบตัวแปร 6 แบบของเจฟฟ์กริกก์ในการวางพารามิเตอร์อินพุตเพื่อเคารพข้อจำกัดความยาวของบรรทัด

คนอื่น ๆ ได้ทำคำแนะนำที่มีประโยชน์แล้วให้ฉันสรุป:

• 80 ตัวอักษรต่อบรรทัดอาจเป็นกฎทองในยุค 80 ทุกวันนี้คนส่วนใหญ่ยอมรับว่า 100 ถึง 130 ตัวอักษรเป็นเรื่องปกติ
• ใช้การแบ่งบรรทัดภายในนิพจน์ของคุณ
• แบ่งการแสดงความยาวโดยแนะนำผลลัพธ์ระดับกลาง

ฉันชอบที่จะเพิ่มคำแนะนำอื่น: อย่าเชื่อในเรื่องชื่อยาว ๆ ! ขอบเขตของตัวแปรที่ใหญ่ขึ้นคือจะต้องใส่ข้อมูลเพิ่มเติมในชื่อของมัน และโดยทั่วไปมันเป็นความคิดที่ดีที่จะรักษาขอบเขตของตัวแปรให้เล็ก

ตัวอย่างเช่นถ้าคุณมีตัวแปรสำหรับคอลัมน์ของตารางการเข้ารหัสคำหลักของคุณและมันเป็นที่ชัดเจนว่ามีเพียงหนึ่งโต๊ะที่ใช้ในขอบเขตของตัวแปรของคุณก็เป็นเรื่องปกติที่จะเรียกมันหรือแม้กระทั่งcolumn colหากขอบเขตมีขนาดใหญ่ขึ้นและมีหลายตารางที่เกี่ยวข้องจะเหมาะสมที่จะเรียกkeyWordEncryptionTableColumnใช้

อีกตัวอย่างหนึ่ง: iถ้าคุณมีห่วงกับร่างกายทอดสองหรือสามสายและมีการใช้ดัชนีสำหรับการเข้าถึงองค์ประกอบของอาร์เรย์มีอะไรผิดปกติกับการเรียกดัชนี ในบริบทนี้มันเป็นมากขึ้นสามารถอ่านได้ (สำหรับคนส่วนใหญ่อย่างน้อย) arrayIndexOfMyVerySpecialDataSetกว่าการพูด

โดยทั่วไปฉันเห็นด้วยกับคุณครู อย่างไรก็ตามหากคุณมีตัวแปรที่คุณจะต้องใช้จำนวนมากในโค้ดขนาดใหญ่ faily มันจะเป็นการดีกว่าที่จะใช้แบบฟอร์มสั้น ๆ สำหรับมันหลังจากชัดเจนเกี่ยวกับความหมายของมัน เช่นเดียวกับเมื่อคุณมีการแสดงออกและการคำนวณทางคณิตศาสตร์ที่ซับซ้อนจำนวนมากสิ่งเหล่านั้นไม่สามารถอ่านได้ดีกับชื่อตัวแปรแบบยาว

เกี่ยวกับการสรุป

ExtractMessage(char keyWord[25], char cipherText[17424],
               int rowSize, char message[388]) 

สิ่งนี้ไม่มีจุดประสงค์เพียง จำกัด ความยาวของบรรทัดไม่ทำให้อ่านง่ายขึ้น หากคุณต้องการให้สิ่งนี้สามารถอ่านได้ให้ทำสิ่งนี้:

ExtractMessage(
  char keyWord[25],
  char cipherText[17424],
  int rowSize,
  char message[388]
  )
{

และจากนั้นคุณอาจต้องการจัดตำแหน่งตัวระบุประเภท (เพิ่มช่องว่างหลังจาก int) อย่างไรก็ตามควรระวัง / จำกัด ด้วยการสรุป initalizations หรือรายการอาร์กิวเมนต์ดังนี้:

int keyColumn    = 0;
int cipherColumn = 0;
int offset       = 1;
int nextWord     = 1;

ปัญหาคือเมื่อคุณเปลี่ยนชื่อหรือเพิ่มตัวแปรคุณอาจต้องฟอร์แมตใหม่ทั้งบล็อกเพื่อรักษารูปลักษณ์ที่สวยงาม มันไม่ได้มีไว้สำหรับการทำงานเท่าที่การเปลี่ยนแปลงที่ไม่มีความหมายที่คุณจะแนะนำมันจะดูน่ากลัวในระบบควบคุมเวอร์ชัน เพื่อนร่วมงานของคุณจะเห็นคุณเปลี่ยนไฟล์และทำสิ่งที่แตกต่างกับเวอร์ชันก่อนหน้าเพื่อดูสิ่งที่คุณทำ จากนั้นทุกบรรทัดจะสว่างขึ้นเมื่อมีการเปลี่ยนแปลงปิดบังการเปลี่ยนแปลงที่แท้จริง มันจะขึ้นอยู่กับคุณภาพของเครื่องมือเปรียบเทียบที่ใช้จริง ๆ แล้วมันจะแย่ขนาดนี้ แต่โดยทั่วไปแล้วมันก็ไม่ควรทำรหัสส่วนตัวเกินไปและ / หรือการจัดรูปแบบของหนึ่งบรรทัดขึ้นอยู่กับอีก

บางครั้งการจัดเค้าร่างสามารถตอบสนองวัตถุประสงค์ถ้าคุณมีหลายสิบบรรทัดติดต่อกันที่เกือบจะเหมือนกันมันจะง่ายต่อการมองเห็นจุดที่พวกเขาแตกต่างกันถ้าคุณร่างพวกเขา

โปรดทราบว่าสถานที่ทำงานอาจมีการจัดรูปแบบอัตโนมัติที่เกิดขึ้นซึ่งจะกำจัดรูปแบบแฟนซีใด ๆ ที่คุณทำกับโค้ดของคุณก่อนที่จะส่งไปยังระบบควบคุมเวอร์ชัน

ข้อจำกัดความรับผิดชอบ: ฉันพูดเกินจริงไปเล็กน้อยเพื่อทำให้ประเด็นของฉันชัดเจนขึ้น ดังนั้นให้นำสุดยอดด้วยเม็ดเกลือ

ครูของคุณถูกต้อง 100%: ไม่มี "กฎทอง" ประมาณ 80 ตัวอักษรอีกต่อไป (เว้นแต่ว่าคุณกำลังเขียนโค้ดลินุกซ์นั่นคือ) กฎนั้นได้รับการจัดตั้งขึ้นเนื่องจากขนาดของเทอร์มินัลในเวลานั้น แต่ทุกวันนี้คุณสามารถอัดตัวอักษรได้มากกว่า 150 ตัวในหน้าต่างเอนเดอร์ของคุณ และแม้ว่าคุณจะเกินขีด จำกัด ตัวแก้ไขของคุณจะหวังว่าจะตัดบรรทัดให้นุ่มเพื่อที่คุณไม่ต้องเลื่อน และเหตุผลเดียวที่จะได้ไปไกลกว่า 80 ตัวอักษรเป็นความต้องการของการเลื่อน

ที่กล่าวว่ามีความจำเป็นที่จะไม่ปล่อยให้บรรทัดของคุณเติบโตอย่างไม่มีกำหนด ยิ่งสายยาวขึ้นเท่าไหร่มันก็ยิ่งยากขึ้นสำหรับมนุษย์ที่จะแยกวิเคราะห์ แต่ชื่อตัวแปรสั้นไม่เป็นวิธีการรักษาสำหรับปัญหาเส้นยาว

วิธีการรักษาคือการแยกการแสดงออกของคุณมีเหตุผลโดยการแนะนำชื่อตัวแปรที่ถูกต้องมากยิ่งขึ้น อย่าพยายามฉลาดด้วยช่องว่าง เพียงระบุ subexpression ใด ๆ ที่สามารถตั้งชื่อ aptly และสร้างตัวแปรให้ ที่ทำให้ทั้งรหัสคำนวณตัวแปรได้ง่ายขึ้นและโค้ดที่ใช้ตัวแปรนั้น

ไม่ใช่ส่วนหนึ่งของคำถามของคุณ แต่ฉันต้องการที่จะแสดงความคิดเห็นกับมัน: มันเป็นความคิดที่ดีมากที่จะจัดแนว=โอเปอเรเตอร์ของคุณในแนวตั้ง

มีสามเหตุผลคือ:

1. การแก้ไขบล็อกที่มีตัวดำเนินการที่ได้รับการกำหนดแนวตั้งคือ PITA เมื่อใดก็ตามที่ความยาวของตัวแปรเปลี่ยนแปลงมากที่สุด (เปลี่ยนชื่อเพิ่มลบ) คุณต้องรีทัชทุกบรรทัดในบล็อกเพื่อให้เลย์เอาต์ "nice" ของคุณกลับมาอีกครั้ง

   แน่นอนว่าปัญหานี้อาจลดลงเล็กน้อยโดยใช้เครื่องมือแก้ไขที่มีความสามารถดังนั้นจึงเป็นเหตุผลเล็กน้อย เหตุผลที่แท้จริงคือข้อที่สอง:

2. gitบรรดาช่องว่างปลอมเปลี่ยนแปลงการแนะนำให้รู้จักในวงกว้างไม่เล่นอย่างกับระบบการควบคุมรุ่นที่ทันสมัยเช่น พวกเขามีแนวโน้มที่จะสร้างความขัดแย้งผสานจำนวนมากโดยที่ไม่มีความขัดแย้งเกิดขึ้นจริงและในกรณีที่ไม่มีข้อขัดแย้งใด ๆ จะถูกส่งสัญญาณหากไม่ได้ใช้การจัดตำแหน่ง ความขัดแย้งปลอมเหล่านี้แต่ละครั้งจะทำให้คุณเสียเวลาอันมีค่าไป

3. การจัดตำแหน่งดำเนินการศูนย์ความหมาย semantical มันไม่มีจุดหมาย ไม่มีอะไรที่คุณสามารถเข้าใจได้ดีขึ้นด้วยการจัดตำแหน่ง ทุกบรรทัดในบล็อกของคุณจำเป็นต้องอ่านด้วยตัวเองเพื่อทำความเข้าใจว่ามันทำอะไรการเชื่อมต่อกับบรรทัดด้านบนและด้านล่างนั้นเป็นลักษณะของการสร้างประโยคอย่างแท้จริง

เนื่องจากการจัดตำแหน่งไม่ได้มีความหมายเชิงความหมายใด ๆ แต่ก่อให้เกิดค่าใช้จ่ายที่สำคัญคุณควรปลดเปลื้องนิสัยก่อนที่จะเสียค่าใช้จ่ายอีกต่อไป

ถ้าคุณชอบความยาว 80 ตัวอักษรลองใช้การเขียนโปรแกรม Fortran จริงมาตรฐานใหม่เพิ่มขีด จำกัด บรรทัด Fortran เป็น 132 ตัวอักษร แต่มันยังคงมีผลเช่นเดียวกับที่ทำให้การรวบรวมโปรแกรมใด ๆ ที่เกินขีด จำกัด หากคุณเก่งเรื่องการเขียนโปรแกรมคุณจะเกลียดชัง Fortran รวมถึงขีดจำกัดความยาวบรรทัด หลังจากนั้นคุณจะหายเป็นปกติตลอดชีวิต

ฉันมีตัวเองต้องเขียนโปรแกรม Fortran อย่างมืออาชีพและฉันบอกคุณมันสอนให้ฉันเกลียดความยาวบรรทัดที่ จำกัด ที่สุด ไม่มีอะไรน่าผิดหวังยิ่งกว่าการแยกสายที่ง่ายและอ่านออกเป็นส่วน ๆ ได้เพียงเพราะคอมไพเลอร์จะไม่รวบรวมมันอย่างถูกต้องอีกต่อไป และมีรหัสบรรทัดที่แน่นอนที่สุดซึ่งง่ายที่สุดเมื่อแสดงเป็นบรรทัดเดียว

การประชุมโวหารมากมาย(ไม่ใช่กฎ!) ผุดขึ้นมาหลายปีเนื่องจากข้อ จำกัด ในสภาพแวดล้อมการเขียนโปรแกรม ย้อนกลับไปในวันชกการ์ดคุณมี ฮาร์ดข้อ จำกัด เกี่ยวกับจำนวนตัวอักษรที่สามารถปรากฏบนบรรทัดแหล่งทางกายภาพ (ซึ่งเป็นเหตุผลที่ Fortran ลิขสิทธิ์คอลัมน์ 6 สำหรับตัวอักษรต่อของบรรทัด) เมื่อไม่กี่สิบปีก่อนที่ฉันทำงานกับเทอร์มินัล VT220 สีเหลืองอำพัน - ดำ - ดำ 80x24; ในขณะที่บรรณาธิการที่ฉันใช้ไม่ได้ จำกัด บรรทัดไว้ที่ 80 ตัวอักษรชีวิตง่ายขึ้นมากถ้าคุณพยายามอย่างที่สุดที่จะหลีกเลี่ยงการเลื่อนแนวนอน

ภายใต้ Fortran เวอร์ชันเก่า (สูงถึง '77, IINM) คุณไม่สามารถมีตัวระบุที่ยาวกว่า 6 ถึง 8 ตัวอักษร แม้เป็นปลายยุค 80, C จะรับประกันเท่านั้นที่ 8 ตัวแรกในชื่อภายนอกมีความหมาย (ซึ่งเป็นเหตุผลที่บางฟังก์ชั่นห้องสมุดมีชื่อที่เป็นคำอธิบายที่เยี่ยมยอดเช่นstrpbrk)

แน่นอนว่าสองทศวรรษในศตวรรษที่ 21 เราไม่มีข้อ จำกัด เหล่านั้นอีกต่อไป ไม่มีเหตุผลที่จะไม่ใช้ตัวระบุที่เป็นคำอธิบายเพิ่มเติม

สิ่งที่เป็นในบริบทที่เหมาะสมiและjและkมีความสมบูรณ์แบบที่เหมาะสมชื่อที่มีความหมาย หากฉันวนซ้ำอาร์เรย์หรือเวกเตอร์เป็นวงกลมและฉันต้องการบางสิ่งบางอย่างเพื่อระบุองค์ประกอบปัจจุบันiทำงานได้ดีอย่างสมบูรณ์ ฉันจะไม่ใช้ชื่อเช่นcurrentElement- มันไม่มีความหมายในบริบทนั้นและมันเพิ่มความยุ่งเหยิงทางสายตา

ต้องบอกว่าอาจารย์ของคุณไม่ผิดที่จะบังคับให้คุณคิดในแง่ของชื่อที่ยาวกว่าและมีความหมายมากขึ้นสำหรับทุกสิ่ง - ชีวิตจะง่ายขึ้นสำหรับคุณถ้าคุณเคยชินกับนิสัยนั้นก่อน เป็นคนที่เป็นที่ครั้งหนึ่งถูกบังคับให้พอดีทุกอย่างลงใน 8 ตัวอักษรหรือน้อยกว่าก็แน่นอนดีกว่าที่จะผิดพลาดในด้านของข้อมูลที่มากกว่าน้อยกว่า ในขณะที่คุณได้รับประสบการณ์มากขึ้นคุณจะได้เรียนรู้ว่าคุณสามารถประหยัดได้ตามความยาวของตัวระบุและที่ใดที่คุณต้องอธิบายให้ละเอียดมากขึ้น

ฉันไม่แน่ใจว่ามันใช้งานได้กับ c หรือไม่ แต่มีวิธีแยกสูตรในหลายบรรทัดหรือไม่ ฉันรู้ว่ามีบางอย่างที่เหมือนกันสำหรับงูหลาม

ดูว่าคุณสามารถเริ่ม + (rowSize * nextWord) + nextWord]) {ในบรรทัดใหม่ (เช่นกด Enter ใน IDE ของคุณและดูว่ามันเยื้องหรือไม่เพื่อให้ C ทราบว่าการแสดงออกก่อนหน้านี้จะเสร็จสมบูรณ์ในบรรทัดปัจจุบัน)