极客教程C++中的命名规则
C++有一套命名变量、函数和代码中其他标识符的规则。这些规则被称为命名约定，有助于使你的代码更易读和可维护。
C++中命名规则的准则
变量名称应该是描述性的和有意义的。例如，一个保存班级中学生人数的变量可以被命名为 “numStudents “或 “studentCount”。
变量名称应使用小写字母，用下划线隔开。例如，”student_count “或 “total_income”。
函数应该用camelCase来命名，每个词的第一个字母用大写，第一个词除外。例如，”calculateTotalIncome “或 “getStudentCount”。
常量应该用大写字母命名，单词之间用下划线分开。例如，”PI “或 “MAX_STUDENT_COUNT”。
类的名称应该用CamelCase，每个词的第一个字母都是大写的，除了第一个词之外。例如，”学生 “或 “CourseEnrollment”。
避免使用其他程序员可能不熟悉的缩写或缩略语。
避免使用保留词或关键字作为变量或函数名称。
C++代码(命名规则)
#include
// PascalCase is often used for function names
void PrintGreeting() {
std::cout << "Hello, world!" << std::endl;
}
int main() {
// camelCase is often used for variable names
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
// Some people use prefixes or suffixes to indicate the type of a variable
// (such as "str" for strings or "arr" for arrays)
std::string strCustomerName = "John Smith";
int arrScores[10] = {0};
// Other people use ALL_CAPS for constants
const int MAX_CUSTOMERS = 100;
// Some people use underscores to separate words in variable names
int num_customers = 10;
double avg_sale_amount = 25.50;
std::string customer_name = "John Smith";
// Finally, some people use Hungarian notation, where the type of a variable
// is indicated by the first few letters of its name (such as "i" for int,
// "d" for double, or "str" for string)
int iCount = 0;
double dTotal = 0.0;
std::string strName = "";
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
std::cout << "Number of customers: " << num_customers << std::endl;
std::cout << "Average sale amount: " << avg_sale_amount << std::endl;
std::cout << "Customer name: " << customer_name << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
Number of customers: 10
Average sale amount: 25.5
Customer name: John Smith
命名规则的优点
以下是在C++中使用一致的命名规则的每个优点的一些例子。
提高可读性： 使用一致的命名约定可以使我们更容易通过观察变量或函数的名称来理解其目的。例如，如果你坚持使用camelCase表示变量，PascalCase表示函数，那么哪些是变量，哪些是函数，一目了然。
C++代码
#include
int main() {
// Using a consistent naming convention (camelCase for variables) makes it
// easier to understand the purpose of each variable.
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
增强可维护性： 一致的命名规则可以帮助你在代码中更容易找到特定的变量或函数。例如，假设你对存储某些类型的数据的变量始终使用一个特定的前缀或后缀（如 “str “代表字符串，”arr “代表数组）。在这种情况下，当你需要进行修改时，就会更容易找到该类型的所有变量。
C++代码
#include
// Using a consistent naming convention (PascalCase for functions) makes it
// easier to locate specific functions in your code.
void PrintGreeting() {
std::cout << "Hello, world!" << std::endl;
}
int main() {
PrintGreeting();
return 0;
}
输出。
Hello, world!
减少错误： 使用一致的命名规则可以帮助减少代码中的错误，因为它使你更容易识别那些名字相似但用途不同的变量或函数。例如，假设你对存储某些类型的数据的变量始终使用一个特定的前缀或后缀（如 “str “代表字符串，”arr “代表数组）。在这种情况下，将更容易发现在特定环境下使用错误的变量类型所造成的错误。
C++代码
#include
int main() {
// Using a consistent naming convention (prefixes to indicate variable type)
// can help reduce errors by making it easier to identify the correct type
// of variable to use in a given context.
int numCustomers = 10;
double avgSaleAmount = 25.50;
std::string customerName = "John Smith";
std::cout << "Number of customers: " << numCustomers << std::endl;
std::cout << "Average sale amount: " << avgSaleAmount << std::endl;
std::cout << "Customer name: " << customerName << std::endl;
return 0;
}
输出。
Number of customers: 10
Average sale amount: 25.5
Customer name: John Smith
增加合作：一个 一致的命名规则可以使多人在同一个代码库中工作更容易，因为它有助于确保每个人都在使用相同的命名规则。这可以帮助避免混乱，减少合并代码变化时的冲突风险。
C++代码
#include
// Using a consistent naming convention (PascalCase for functions) can help
// ensure that multiple people working on the same codebase are using the same
// conventions, which can reduce conflicts and confusion when merging code
// changes.
void PrintGreeting() {
std::cout << "Hello, world!" << std::endl;
}
int main() {
PrintGreeting();
return 0;
}
输出。
Hello, world!
增强专业性： 遵守一致的命名规则表明了专业性和对细节的关注，这在与客户合作的项目中或在专业环境中可能特别重要。使用一致的命名规则还可以使你的代码在视觉上更吸引人，更容易阅读，这在任何情况下都是一笔宝贵的财富。
C++代码
#include
int main() {
// Using a consistent naming convention (camelCase for variables) can make
// your code more visually appealing and easier to read, which can be a
// valuable asset in any situation.
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
命名规则的缺点
在C++中使用命名约定有几个潜在的缺点。
额外的努力： 遵守一致的命名约定需要额外的努力和纪律，因为你必须记住在每次命名一个变量或函数时使用正确的约定。如果你和一个有不同命名惯例的团队一起工作，或者你正在做的项目要求你遵循与你习惯不同的特定命名惯例，这可能是一个特别的挑战。
C++代码
#include
int main() {
// Adhering to a consistent naming convention (camelCase for variables)
// requires extra effort and discipline, as you have to remember to use the
// correct conventions every time you name a variable or function.
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
限制： 使用一致的命名规则也可能是限制性的，因为它可能限制你可以为变量或函数使用的名称。例如，如果你使用的命名规则要求你对某些类型的变量使用特定的前缀或后缀，你可能无法使用某些你喜欢的名字。
C++代码
#include
int main() {
// Using a consistent naming convention (prefixes to indicate variable type)
// can be limiting, as it may restrict the names you can use for variables.
// For example, if you want to use a name like "customer_name" for a string
// variable, you may not be able to do so if your naming convention requires
// you to use a specific prefix or suffix (such as "str" or "s").
std::string strCustomerName = "John Smith";
std::cout << "Customer name: " << strCustomerName << std::endl;
return 0;
}
输出。
Customer name: John Smith
潜在的冲突： 不同的人或团队在涉及到命名规则时可能有不同的偏好，如果大家不在同一条线上，就会导致冲突。如果你在一个有许多贡献者的大型项目上工作，这可能是特别有问题的。
C++代码
#include
int main() {
// Different people or teams may have different preferences when it comes to
// naming conventions, which can lead to conflicts if everyone is not on the
// same page.
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
缺乏灵活性： 根据你所使用的命名惯例，它可能并不总是最合适或最直观的选择，适合各种情况。例如，如果你使用的惯例要求你对变量使用camelCase，那么你可能不得不为变量想出不那么直观的名字，而使用下划线或其他分隔符可以更自然地表达。
C++代码
#include
int main() {
// Depending on the naming convention you are using, it may not always be the
// most appropriate or intuitive choice for every situation. For example, if
// you are using a convention that requires you to use camelCase for variables,
// you may have to come up with less intuitive names for variables that would
// be more naturally expressed using underscores or other separators.
int num_customers = 10;
double avg_sale_amount = 25.50;
std::string customer_name = "John Smith";
std::cout << "Number of customers: " << num_customers << std::endl;
std::cout << "Average sale amount: " << avg_sale_amount << std::endl;
std::cout << "Customer name: " << customer_name << std::endl;
return 0;
}
输出。
Number of customers:
C++、Python、Java和C都是编程语言，在命名变量和函数方面有自己的惯例。下面是这些语言所遵循的命名惯例之间的一些主要区别。C++：在C++中，变量和函数通常使用camelCase来命名，除了第一个单词外，每个单词的第一个字母都是大写的（例如，”numberOfApples”）。常量变量通常使用ALL_CAPS命名，单词之间用下划线隔开（例如，”MAX_CUSTOMERS”）。
例子
#include
// camelCase is often used for variable names
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
// ALL_CAPS is often used for constant variables
const int MAX_CUSTOMERS = 100;
int main() {
std::cout << "We have " << totalFruit << " pieces of fruit." << std::endl;
std::cout << "MAX_CUSTOMERS is " << MAX_CUSTOMERS << "." << std::endl;
return 0;
}
输出。
We have 8 pieces of fruit.
MAX_CUSTOMERS is 100.
Python。在Python中，变量和函数通常使用snake_case来命名，其中下划线分隔单词（例如，”number_of_apples”）。常量变量通常使用 ALL_CAPS 命名，单词之间用下划线隔开 (例如，”MAX_CUSTOMERS”)。
例子
# snake_case is often used for variable names
number_of_apples = 5
number_of_oranges = 3
total_fruit = number_of_apples + number_of_oranges
# ALL_CAPS is often used for constant variables
MAX_CUSTOMERS = 100
print(f"We have {total_fruit} pieces of fruit.")
print(f"MAX_CUSTOMERS is {MAX_CUSTOMERS}.")
输出。
We have 8 pieces of fruit.
MAX_CUSTOMERS is 100.
Java： 在Java中，变量和函数通常使用camelCase来命名，每个词的第一个字母都大写，但第一个词除外（例如，”numberOfApples”）。常量变量通常使用ALL_CAPS来命名，单词之间用下划线隔开（例如，”MAX_CUSTOMERS”）。C：在C语言中，变量和函数通常使用snake_case来命名，用下划线分隔单词（例如，”number_of_apples”）。
常量变量通常使用ALL_CAPS来命名，用下划线分隔单词（例如，”MAX_CUSTOMERS”）。需要注意的是，这些只是一般的惯例，在任何一种语言中都有可能使用不同的命名惯例。然而，一般来说，遵守你工作的语言或社区所遵循的惯例是个好主意，因为它使其他人更容易阅读和理解你的代码。
例子
public class Main {
// camelCase is often used for variable names
int numberOfApples = 5;
int numberOfOranges = 3;
int totalFruit = numberOfApples + numberOfOranges;
// ALL_CAPS is often used for constant variables
static final int MAX_CUSTOMERS = 100;
public static void main(String[] args) {
System.out.println("We have " + totalFruit + " pieces of fruit.");
System.out.println("MAX_CUSTOMERS is " + MAX_CUSTOMERS + ".");
}
}
输出。
We have 8 pieces of fruit.
MAX_CUSTOMERS is 100.