第 12 節

Advanced Functions and Namespaces

0瀏覽次數0訪問次數--跳出率--平均停留

Function Optimization

default function parameters

In C++, the parameters in a function's parameter list can have default values.

Grammar: 返回值类型函数名（参数= 默认值）{}

Example:

int func(int a, int b = 10, int c = 10) {
    return a + b + c;
}

//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数
int func2(int a = 10, int b = 10);
int func2(int a, int b) {
    return a + b;
}

int main() {

    cout << "ret = " << func(20, 20) << endl;
    cout << "ret = " << func(100) << endl;


    return 0;
}

Running/Observation Results: After running, the corresponding content will be printed according to the output statements. The variable values can be inferred based on the order of initialization, assignment, and function calls.

Function Placeholder Parameters

In C++, function parameter lists can have placeholder parameters used as placeholders, and when calling the function, that position must be filled.

Syntax: 返回值类型函数名 (数据类型){}

At this stage, the placeholder parameters in functions have little significance, but this technique will be used in later lessons.

Example:

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
    cout << "this is func" << endl;
}

int main() {

    func(10,10); //占位参数必须填补


    return 0;
}

Running/Observing the results: After running, the example will print variable values or addresses; address values depend on the runtime environment, so focus on observing the relative positioning and pointer changes of similar objects.

function overloading

Function Overloading Overview

Purpose: Functions can share the same name, improving reusability

Function overloading satisfies the conditions:

Under the same scope
Function names are the same
Different types of function parameters, or different counts, or different orders

Note: Return values cannot be used as conditions for function overloading.

Example:

//函数重载需要函数都在同一个作用域下
void func()
{
    cout << "func 的调用！" << endl;
}
void func(int a)
{
    cout << "func (int a) 的调用！" << endl;
}
void func(double a)
{
    cout << "func (double a)的调用！" << endl;
}
void func(int a ,double b)
{
    cout << "func (int a ,double b) 的调用！" << endl;
}
void func(double a ,int b)
{
    cout << "func (double a ,int b)的调用！" << endl;
}

//函数返回值不可以作为函数重载条件
//int func(double a, int b)
//{
//  cout << "func (double a ,int b)的调用！" << endl;
//}

int main() {

    func();
    func(10);
    func(3.14);
    func(10,3.14);
    func(3.14 , 10);
    

    return 0;
}

Function Overloading Considerations

References as Overload Conditions
Function Overloading with Function Default Parameters

Example:

//函数重载注意事项
//1、引用作为重载条件

void func(int &a)
{
    cout << "func (int &a) 调用 " << endl;
}

void func(const int &a)
{
    cout << "func (const int &a) 调用 " << endl;
}

//2、函数重载碰到函数默认参数

void func2(int a, int b = 10)
{
    cout << "func2(int a, int b = 10) 调用" << endl;
}

void func2(int a)
{
    cout << "func2(int a) 调用" << endl;
}

int main() {
    
    int a = 10;
    func(a); //调用无const
    func(10);//调用有const

    //func2(10); //碰到默认参数产生歧义，需要避免


    return 0;
}

Namespace and Name Conflicts

In a C++ application. For example, you might write a function named xyz(), and another available library also contains an identical function xyz(). In this case, the compiler cannot determine which xyz() function you are using.

Therefore, the concept of namespace was introduced specifically to solve the above problem. It serves as additional information to distinguish functions, classes, variables, etc. that share the same name across different libraries. Using a namespace defines a context. Essentially, a namespace defines a scope.

Define the namespace

The definition of a namespace uses the keyword namespace, followed by the name of the namespace, as shown below:

namespace namespace_name {
   // 代码声明
}

Run/Observation Results: This section is syntax definition-focused, typically requiring compilation together with the calling code. Pay attention to the definition method and usage location.

To call a function or variable with a namespace, you need to prefix it with the namespace name, as shown below:

name::code;  // code 可以是变量或函数

Running/Observing Results: This is a syntax or interface example, focus on the writing style; run and verify after incorporating it into a complete program.

using the command

You can use the using namespace directive, so that when using the namespace, you don't need to prefix it with the namespace name. This directive tells the compiler that subsequent code will use names from the specified namespace.

#include <iostream>
using namespace std;

// 第一个命名空间
namespace first_space{
   void func(){
      cout << "Inside first_space" << endl;
   }
}
// 第二个命名空间
namespace second_space{
   void func(){
      cout << "Inside second_space" << endl;
   }
}

// 第三个命名空间
namespace third_space{
   void func()
   {
      cout << "Inside second_space" << endl;
   }
}

using namespace first_space;
using second_space::func;    //(与25行代码建议不能共存，因为都导入了func()函数)，（这种方法更好更推荐）

int main ()
{

   // 调用第一个命名空间中的函数
   func();
   // 调用第二个命名空间中的函数   
   func();         //(与32行代码不能共存)
   //调用第三个命名空间中的函数
   third_space::func();

   return 0;
}

Nested namespaces

Namespaces can be nested. You can define one namespace inside another, as shown below:

namespace namespace_name1 {
   // 代码声明
   namespace namespace_name2 {
      // 代码声明
   }
}

Run/Observation Results: This section is syntax definition-focused, typically requiring compilation together with the calling code. Pay attention to the definition method and usage location.

You can access members in a nested namespace by using the :: operator:

// 访问 namespace_name2 中的成员
using namespace namespace_name1::namespace_name2;

// 访问 namespace_name1 中的成员
using namespace namespace_name1;

Run/Observation Results: This section is syntax definition-focused, typically requiring compilation together with the calling code. Pay attention to the definition method and usage location.