C++ Programming Practices

1. Data Interaction

The rapid popularization and development of computer technology can be attributed to its ability to interact with various operators, which fundamentally involves data interaction. Regardless of whether it is commands or key presses, they ultimately manifest in the computer system as responses to different data situations, resulting in varying operational outcomes. Generally, common ways for users to interact with computers include the following:

1. Command Line InteractionThis is the most typical and earliest form of interaction, especially during the DOS era, where it was essentially mainstream. It is the familiar dark window where various commands are input and relevant results are viewed.
2. UI InteractionSince the advent of Windows, this interaction method has gradually become mainstream, while the complexity of command interaction has faded. This interaction method encompasses many forms, such as using a keyboard, mouse, or touchscreen.
3. File InteractionIn the process of interacting with computers, passing data in and out through files is a classic method. Even today, files remain an important type of interaction with computers. Additionally, devices or software can also be abstracted as files, a method that is now very common, such as in Linux where everything is treated as a file.
4. Intelligent InteractionThis method has only recently gained attention, where interaction is achieved through algorithms or AI systems using voice, image recognition, gestures, etc.
5. OthersThis includes niche methods such as old-fashioned interaction methods represented by punch card machines and advanced interaction methods like brain-computer interfaces in laboratories.

2. Security and Efficiency of Interaction

Have you ever seen reports of a system-level issue from a few years ago, where a foreign girl could repeatedly press keys randomly to directly enter the system without needing to input a username and password? This is a very rare but typical real-world example. For the vast majority of people, operations are conducted within a set of rules, and it is very rare or nearly impossible to perform illegal operations. A real-world example makes this clear: everyone knows that running a red light is illegal, so normal people are highly unlikely to do so. However, this does not mean that no one runs red lights; these individuals may include those with issues, those in emergencies, or those who are careless, among others. Ultimately, these situations are the minority; otherwise, traffic would be chaotic.Similarly, data interaction between computers and operators must also handle these rare behaviors without compromising the efficiency of normal interactions. A balance must be achieved: security cannot be sacrificed for efficiency, nor can excessive and complex security checks be introduced at the expense of efficiency. When considering security and efficiency, the following points should be noted:

1. Data Validity VerificationThis includes using assertions, regular expressions, etc., to determine the validity of data interactions. Various checks should be performed on data before outputting it. Common examples include user email input and live detection during facial interactions.
2. Error and Exception HandlingWhen errors and exceptions occur, how to safely control the state of data interaction to ensure the program continues to run safely and can recover the relevant operational state. For example, if a user intentionally inputs an incorrect command in the command window, the window will prompt that the command does not exist and return the current command status and relevant explanations, suggesting similar commands if applicable.

3. Common Handling Methods

For handling data interactions, generally, the following methods are employed under the premise of security:

1. Overall Interaction DesignThe robustness of software is fundamental, and the corruption of interaction data is often a significant cause of software crashes. Therefore, various security checks and logical judgments must be conducted on interaction data as a whole. For instance, verifying whether a robot is operating on a webpage.
2. Data Checking and PreprocessingThis includes common checks on password length, command parameters, etc., which need to be restricted and verified; simultaneously, preprocessing of relevant data inputs and outputs is required, which is commonly known as data cleaning and filtering. A common example is that before outputting analyzed data, sensitive data must be cleaned and filtered; otherwise, it may lead to socially detrimental program instability.
3. Fault Tolerance and Recovery MechanismsAllow for appropriate controllable erroneous inputs, and in the case of uncontrollable erroneous inputs leading to exceptions, the system should be able to recover to the initial or specified state (i.e., degradation, which is a strong requirement in e-commerce sites), without affecting subsequent data interactions.
4. Logging and MonitoringUtilize logs to record relevant issues (including details of interest, such as the operator, etc.), and promptly notify relevant personnel when problems are detected.
5. Comprehensive TestingDevelopers should understand that from unit testing to final integration testing, it is a crucial mechanism to significantly reduce data interaction issues.

4. Practices in C++

Based on the handling methods mentioned above, the following practices are generally used in C++:

1. Data Checking

// Array out of bounds
#define N 100

int arr[N] ={0};
void test(int i){
if (i < N){...}
}
// Regular email check
bool isValid(const std::string& email){
const std::regex pattern(
        R"(^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$)"
    );

auto ret = std::regex_match(email, pattern);
return ret;
}

1. Error Handling

// Assertion
assert(b != 0);
int c = a / b;
// Error code 
int fd = open("test.txt", O_RDONLY);
if (fd == -1){}
// Exception
#include 
#include  // Include standard exception class

void checkNumber(int number) {
     throw std::runtime_error("run err!"); 
}

int main() {
    try {
        checkNumber(3);  
    } catch (const std::exception& e) { 
        std::cerr << "exception: " << e.what() << std::endl;
    }
    return 0;
}

1. Logging

// Using Google logging
LOG(INFO) << "test info!";

1. Type Validation

// SFINAE
template
struct IsBase : std::false_type {};

template
struct IsBase<t, std::enable_if_t<std::is_base_of::value>> : std::true_type {};
// Concepts or constraints
template
void checkIsBase() {
    if constexpr (std::is_base_of_v) {
        std::cout << " is OK!" << std::endl;
    } else {
        std::cout << " no is!" << std::endl;
    }
}

The above code is quite easy to understand; you can refer to it. In fact, those who have written similar code understand that data validation is often very complex, especially for interaction interfaces related to money, where validation can be quite intricate.

5. Conclusion

On construction sites in the real world, one often sees slogans like “Safety First.” The same applies to the world of computers; data interaction, as one of the prerequisites for computers to become the most effective tools for humanity, requires various security measures, which are a very important and necessary mechanism. An excellent architect and developer must recognize this premise; otherwise, their work will be like a tree without roots.