输入和输出参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>

void print(int x) // x 是输入参数
{
    std::cout << x << '\n';
}

void print(const std::string& s) // s 是输入参数
{
    std::cout << s << '\n';
}

int main()
{
    print(5);
    std::string s { "Hello, world!" };
    print(s);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <cmath>    // for std::sin() 和 std::cos()
#include <iostream>

// sinOut 和 cosOut 是输出参数
void getSinCos(double degrees, double& sinOut, double& cosOut)
{
    // sin() 和 cos() 需要弧度, 而不是角度, 所以需要转换下
    constexpr double pi { 3.14159265358979323846 }; // π的值
    double radians = degrees * pi / 180.0;
    sinOut = std::sin(radians);
    cosOut = std::cos(radians);
}
 
int main()
{
    double sin { 0.0 };
    double cos { 0.0 };
 
    double degrees{};
    std::cout << "Enter the number of degrees: ";
    std::cin >> degrees;

    // getSinCos 将会同时返回sin和cos计算的结果
    getSinCos(degrees, sin, cos);
 
    std::cout << "The sin is " << sin << '\n';
    std::cout << "The cos is " << cos << '\n';

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

#include <iostream>

int getByValue()
{
    return 5;
}

void getByReference(int& x)
{
    x = 5;
}

int main()
{
    // 按值返回
    [[maybe_unused]] int x{ getByValue() }; // 可以用来初始化变量
    std::cout << getByValue() << '\n';      // 可以用来当做临时对象

    // 使用输出参数
    int y{};                // 首先需要初始化一个可被赋值的对象
    getByReference(y);      // 使用函数为该对象赋值
    std::cout << y << '\n'; // 然后使用该对象

    return 0;
}

1

x = getByValue(); // 显然x被修改

1

    getSinCos(degrees, sin, cos);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

void foo1(int x);  // 按值传递
void foo2(int& x); // 按引用传递
void foo3(int* x); // 按地址传递

int main()
{
    int i{};
 
    foo1(i);  // 无法修改 i
    foo2(i);  // 可以修改 i
    foo3(&i); // 可以修改 i

    int *ptr { &i };
    foo3(ptr); // 可以修改 i

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void someFcn(Foo& inout)
{
    // 修改 inout
}

int main()
{
    Foo foo{};
    someFcn(foo); // foo 在调用后会被修改, 但可能不太明显看出来

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void modifyFoo(Foo& inout)
{
    // 修改 inout
}

int main()
{
    Foo foo{};
    modifyFoo(foo); // foo 在调用后会被修改, 稍微可读一点

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

Foo someFcn(const Foo& in)
{
    Foo foo { in }; // 拷贝
    // 修改 foo
    
    // 返回 foo
    return foo;
}

int main()
{
    Foo foo{};
    foo = someFcn(foo); // 明显看出foo被修改，但代码性能差

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void generateExpensiveFoo(Foo& out)
{
    // 修改 out
}

int main()
{
    Foo foo{};
    generateExpensiveFoo(foo); // foo 在调用后会被修改

    return 0;
}