Runtime
C++与Go系列(一)
编辑
2024-07-19
编程语言
00
请注意，本文编写于 183 天前，最后修改于 161 天前，其中某些信息可能已经过时。

目录

声明和定义
C++中的声明和定义
行末尾分号
C++
Go
函数定义
C++
Go
控制结构
条件语句
C++
Go
循环语句
C++
Go
数据结构
数组
C++
Go
字典/映射
C++
Go
结构体
C++ 中的结构（Struct）
定义和使用
关键特点
Go 中的结构（Struct）
定义和使用
关键特点
Go语言的变量和函数大小写规则
大写开头的变量和函数
小写开头的变量和函数
总结

C++与Go系列之基础语法篇

声明和定义

C++中的声明和定义

声明（Declaration）

声明告诉编译器变量、函数或类型的名称和类型，但不分配存储空间或定义其实现。声明通常出现在头文件中，以便其他文件可以引用这些声明。

示例：

  1. 变量声明

    cpp
    int a; // 声明变量a，未分配存储空间

  2. 函数声明

    cpp
    int add(int, int); // 声明函数add，没有提供函数实现

  3. 类声明

    cpp
    class MyClass; // 前向声明类MyClass，没有定义类的成员

在C++中，变量的声明需要指定数据类型。

cpp
#include <iostream>

int main() {
    int a = 10;
    double b = 3.14;
    std::string s = "Hello, C++";

    std::cout << a << " " << b << " " << s << std::endl;
    return 0;
}

定义（Definition）

定义不仅声明了变量、函数或类型的名称和类型，还分配存储空间或提供实现。定义通常出现在源文件中。

示例：

  1. 变量定义

    cpp
    int a = 10; // 定义变量a，并分配存储空间

  2. 函数定义

    cpp
    int add(int x, int y) {
    return x + y;
} // 定义函数add，并提供函数实现

  3. 类定义

    cpp
    class MyClass {
public:
    void doSomething();
}; // 定义类MyClass，并提供类的成员声明

Go语言中的声明和定义

Go语言中，声明和定义往往是同时进行的。每次声明变量或函数时，通常也会同时进行定义。

声明和定义变量

在Go中，变量声明通常伴随着定义。

go
package main

import "fmt"

func main() {
    var a int = 10 // 声明并定义变量a
    b := 20       // 简短声明并定义变量b

    fmt.Println(a, b)
}

声明和定义函数

函数声明和定义也是同时进行的。

go
package main

import "fmt"

func add(x, y int) int { // 声明并定义函数add
    return x + y
}

func main() {
    result := add(3, 4)
    fmt.Println("3 + 4 =", result)
}

声明和定义类型

Go语言中也可以声明和定义自定义类型。

go
package main

import "fmt"

type MyStruct struct { // 声明并定义结构体MyStruct
    x int
    y int
}

func main() {
    var s MyStruct // 声明并定义变量s
    s.x = 10
    s.y = 20

    fmt.Println(s)
}

Go语言的变量声明需要指定数据类型，但提供了更简洁的声明方式（使用:=操作符）。

go
package main

import "fmt"

func main() {
    var a int = 10
    var b float64 = 3.14
    var s string = "Hello, Go"

    // 简洁声明
    x := 42
    y := 2.718
    z := "Go is fun"

    fmt.Println(a, b, s)
    fmt.Println(x, y, z)
}

行末尾分号

C++

在C++中，大多数语句和声明都需要以分号结尾。这是C++语法的基本要求，用于分隔各个语句。

cpp
#include <iostream>

int main() {
    int a = 10;  // 变量声明需要分号
    int b = 20;  // 变量声明需要分号

    std::cout << a + b << std::endl;  // 输出语句需要分号
    return 0;  // 返回语句需要分号
}

Go

在Go中，行末不需要显式的分号。Go编译器会自动在每行的末尾插入分号。然而，在同一行内编写多条语句时，仍需使用分号进行分隔。

go
package main

import "fmt"

func main() {
    a := 10 // 变量声明不需要分号
    b := 20 // 变量声明不需要分号

    fmt.Println(a + b) // 输出语句不需要分号

    a++; b++ // 在同一行内编写多条语句时，需要分号进行分隔
    fmt.Println(a, b)
}

函数定义

C++

C++中，函数的定义需要指定返回类型和参数类型。

cpp
#include <iostream>

int add(int x, int y) {
    return x + y;
}

int main() {
    int result = add(3, 4);
    std::cout << "3 + 4 = " << result << std::endl;
    return 0;
}

Go

Go语言的函数定义也需要指定返回类型和参数类型，但参数类型可以一起声明。

go
package main

import "fmt"

func add(x, y int) int {
    return x + y
}

func main() {
    result := add(3, 4)
    fmt.Println("3 + 4 =", result)
}

控制结构

条件语句

C++

C++的条件语句与其他C风格语言类似。

cpp
#include <iostream>

int main() {
    int a = 10;

    if (a > 5) {
        std::cout << "a is greater than 5" << std::endl;
    } else {
        std::cout << "a is not greater than 5" << std::endl;
    }

    return 0;
}
Go

Go语言的条件语句与C++相似，但不需要括号。

go
package main

import "fmt"

func main() {
    a := 10

    if a > 5 {
        fmt.Println("a is greater than 5")
    } else {
        fmt.Println("a is not greater than 5")
    }
}

此外，Go语言允许在if语句中使用一个简单语句，用分号与条件分隔开，这在C++中是没有的。

if语句中的简单语句

Go语言中的if语句可以在条件判断之前执行一个简单语句，这个语句和条件之间用分号分隔。这样的用法在一些场景中非常有用，例如需要在条件判断前计算某个值。

go
package main

import "fmt"

func main() {
    if b := 20; b > 15 {
        fmt.Println("b is greater than 15")
    } else {
        fmt.Println("b is not greater than 15")
    }
}

在这个示例中，b := 20是一个简单语句，它在条件判断前执行。这个简单语句的作用域仅限于if-else语句块内。

if-else if-else 语句

Go语言中的if-else if-else语句也支持这种简单语句的用法：

go
package main

import "fmt"

func main() {
    if c := 25; c > 30 {
        fmt.Println("c is greater than 30")
    } else if c > 20 {
        fmt.Println("c is greater than 20 but less than or equal to 30")
    } else {
        fmt.Println("c is less than or equal to 20")
    }
}

循环语句

C++

C++支持多种循环结构，如for、while和do-while。

cpp
#include <iostream>

int main() {
    for (int i = 0; i < 5; ++i) {
        std::cout << i << " ";
    }
    std::cout << std::endl;

    int j = 0;
    while (j < 5) {
        std::cout << j << " ";
        ++j;
    }
    std::cout << std::endl;

    int k = 0;
    do {
        std::cout << k << " ";
        ++k;
    } while (k < 5);
    std::cout << std::endl;

    return 0;
}
Go

Go语言仅支持一种循环结构for，可以实现C++中的所有循环。

go
package main

import "fmt"

func main() {
    for i := 0; i < 5; i++ {
        fmt.Print(i, " ")
    }
    fmt.Println()

    j := 0
    for j < 5 {
        fmt.Print(j, " ")
        j++
    }
    fmt.Println()

    k := 0
    for {
        fmt.Print(k, " ")
        k++
        if k >= 5 {
            break
        }
    }
    fmt.Println()
}

数据结构

数组

C++

在C++中，数组可以使用固定大小或动态分配。

cpp
#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};

    for (int i = 0; i < 5; ++i) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;

    return 0;
}
Go

Go语言中的数组和切片（slice）提供了更灵活的方式来管理集合数据。 （slice实际上是一个结构体）

go
package mainß

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}

    for i := 0; i < len(arr); i++ {
        fmt.Print(arr[i], " ")
    }
    fmt.Println()

    // 使用切片
    slice := []int{1, 2, 3, 4, 5}
    for _, v := range slice {
        fmt.Print(v, " ")
    }
    fmt.Println()
}

字典/映射

C++

C++使用std::map或std::unordered_map来实现字典

cpp
#include <iostream>
#include <map>

int main() {
    std::map<std::string, int> dict;
    dict["one"] = 1;
    dict["two"] = 2;

    for (const auto& pair : dict) {
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}
Go

Go语言使用map关键字来实现字典。

go
package main

import "fmt"

func main() {
    dict := map[string]int{
        "one": 1,
        "two": 2,
    }

    for key, value := range dict {
        fmt.Println(key, ":", value)
    }
}

结构体

C++ 中的结构（Struct）

定义和使用

在C++中，结构（struct）是一种用户定义的数据类型，类似于类（class），但有一些关键的区别。结构体主要用于将不同类型的数据组合在一起。

cpp
#include <iostream>
#include <string>

struct Person {
    std::string name;
    int age;
    
    // 可以在结构体中定义成员函数
    void introduce() {
        std::cout << "My name is " << name << " and I am " << age << " years old." << std::endl;
    }
};

int main() {
    // 创建结构体实例
    Person person1;
    person1.name = "Alice";
    person1.age = 30;
    
    // 调用结构体的成员函数
    person1.introduce();
    
    return 0;
}
关键特点
  1. 默认访问控制：C++中的结构体成员默认是public的，而类的成员默认是private的。
  2. 成员函数：结构体可以包含成员函数，就像类一样。
  3. 继承：C++的结构体可以进行继承，但通常情况下更倾向于使用类进行继承。

Go 中的结构（Struct）

定义和使用

在Go中，结构体（struct）也是一种用户定义的数据类型，用于将一组不同类型的数据组合在一起。Go语言的结构体在语法上与C++有一些相似，但在使用上有一些显著的不同。

go
package main

import "fmt"

// 定义结构体
type Person struct {
    Name string
    Age  int
}

// 定义方法
func (p Person) Introduce() {
    fmt.Printf("My name is %s and I am %d years old.\n", p.Name, p.Age)
}

func main() {
    // 创建结构体实例
    person1 := Person{Name: "Alice", Age: 30}
    
    // 调用结构体的方法
    person1.Introduce()
}
关键特点
  1. 默认访问控制：Go语言中，结构体的成员名首字母大写表示导出（public），首字母小写表示未导出（private）。
  2. 方法：Go语言通过方法来为结构体定义行为，方法可以是值接收者（值传递）或指针接收者（引用传递）。
  3. 嵌入和组合：Go语言没有传统的继承机制，而是通过嵌入其他结构体来实现代码复用。

Go语言的变量和函数大小写规则

在Go语言中，变量和函数名称的首字母大小写决定了它们的可见性（visibility）。具体规则如下：

大写开头的变量和函数

大写开头的变量和函数在包外可见，即它们是导出的（exported）。这意味着它们可以被其他包导入和使用。

示例：

go
package main

import "fmt"

// 导出的变量
var PublicVar = "I am visible outside this package"

// 导出的函数
func PublicFunc() {
    fmt.Println("I am visible outside this package")
}

func main() {
    fmt.Println(PublicVar)
    PublicFunc()
}

在另一个包中，可以这样使用导出的变量和函数：

go
package main

import (
    "fmt"
    "path/to/your/package"
)

func main() {
    fmt.Println(package.PublicVar)
    package.PublicFunc()
}

小写开头的变量和函数

小写开头的变量和函数在包外不可见，即它们是未导出的（unexported）。这意味着它们只能在声明它们的包内使用。

示例：

go
package main

import "fmt"

// 未导出的变量
var privateVar = "I am not visible outside this package"

// 未导出的函数
func privateFunc() {
    fmt.Println("I am not visible outside this package")
}

func main() {
    fmt.Println(privateVar)
    privateFunc()
}

在另一个包中，无法访问未导出的变量和函数：

go
package main

import (
    "fmt"
    "path/to/your/package"
)

func main() {
    // fmt.Println(package.privateVar) // 编译错误：无法访问未导出的变量
    // package.privateFunc()           // 编译错误：无法访问未导出的函数
}

总结

C++需要在大多数语句和声明末尾使用分号，而Go语言则不需要。Go语言通过变量和函数名称的大小写规则来控制可见性。

本文作者:phae

本文链接:

版权声明:本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！