C语言函数使用for循环出错

Posted 2023-05-06

这个代码哪里错了，为什么求的值都是0
#include<stdio.h>
void main()

int a[3][2], i, j;
int ave(int a[3][2]);
for (i = 0; i < 3; i++)

printf("学生%d的成绩\n", i + 1);
for (j = 0; j < 2; j++)


scanf_s("%d",&a[i][j]);


ave(a);

system("pause");


int ave(int a[3][2])

int i, j;
float sum = 0;
for (i = 0; i < 3; i++)

for (j = 0; j < 2; j++)

sum += a[i][j];

printf("%d学生的平均成绩为%d\n", i + 1, sum /2);



return 0;

参考技术A j=t*100
while(j--)
这里的while语句和for语句各起什么作用？

是指循环
j*i
次吗？
for(i=8505;i;i--);


//============================================
空跑，也就是延时的作用，
for(i=8505;i;i--);一次全循环应该是1ms，void
delay(float
t)应该是延时t*100ms 参考技术B int ave(int a[3][2])

 int i, j;
 int sum = 0;//这里用int代替float或者再下面的printf中将第二个%d改为%f
 for (i = 0; i < 3; i++)
 
  sum = 0;//新增这一行 这样才能保证每个学生的平均成绩单独计算
  for (j = 0; j < 2; j++)
  
   sum += a[i][j];
  
  printf("%d学生的平均成绩为%d\\n", i + 1, sum /2);
 
 return 0;

追问

谢谢指点，我刚刚接触也不明白。

参考技术C 函数avg中，sum定义的类型是浮点型，但是输出时却要求按整型输出。
printf("%d学生的平均成绩为%d\n", i + 1, sum /2);
改为
printf("%d学生的平均成绩为%f\n", i + 1, sum /2);追问

谢谢指点，我刚刚接触也不明白。

本回答被提问者采纳

Go语言 | 02 for循环及常用函数的使用

文章目录

• 前言
• for & range函数
• • for语法
  • for使用
  • range遍历
  • for循环嵌套
  • break
• make & map函数
• • make（集合）
  • map（范围）
  • delete() 函数
• Go语言函数
• • 函数定义
  • 函数调用
  • 函数返回多个值
  • Go语言函数值传递值
  • Go语言函数引用传递值
  • Go语言函数作为实参

前言

本以为Go语言和C语言相似度较高，但是在for循环的学习中，还是感觉有很多的不同， 因此做个学习记录

for & range函数

for语法

Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。

和 C 语言的 for 一样：

for init; condition; post  

和 C 的 while 一样：

for condition  

和 C 的 for(;😉 一样：

for  

• init： 一般为赋值表达式，给控制变量赋初值；
• condition： 关系表达式或逻辑表达式，循环控制条件；
• post： 一般为赋值表达式，给控制变量增量或减量。
  range是我之前在C语言开发中没怎么使用到过的

for使用

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap 
    newMap[key] = value

以上代码中的 key 和 value 是可以省略。

如果只想读取 key，格式如下：

for key := range oldMap

或者这样：

for key, _ := range oldMap

如果只想读取 value，格式如下：

for _, value := range oldMap

示例代码

package main

import "fmt"

var pow = []int1, 2, 4, 8, 16, 32, 64, 128

func main() 
   for i, v := range pow 
      fmt.Printf("2**%d = %d\\n", i, v)
   

以上实例运行输出结果为：

for 循环的 range 格式可以省略 key 和 value，如下实例：

package main
import "fmt"

func main() 
    map1 := make(map[int]float32)
    map1[1] = 1.0
    map1[2] = 2.0
    map1[3] = 3.0
    map1[4] = 4.0
   
    // 读取 key 和 value
    for key, value := range map1 
      fmt.Printf("key is: %d - value is: %f\\n", key, value)
    

    // 读取 key
    for key := range map1 
      fmt.Printf("key is: %d\\n", key)
    

    // 读取 value
    for _, value := range map1 
      fmt.Printf("value is: %f\\n", value)
    

以上实例运行输出结果为:

多次运行我们就可以发现就像之前说的，map的无序，这个后面会提到

range遍历

package main
import "fmt"
func main() 
    //这是我们使用 range 去求一个 slice 的和。使用数组跟这个很类似
    nums := []int2, 3, 4
    sum := 0
    for _, num := range nums 
        sum += num
    
    fmt.Println("sum:", sum)
    //在数组上使用 range 将传入索引和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
    for i, num := range nums 
        if num == 3 
            fmt.Println("index:", i)
        
    
    //range 也可以用在 map 的键值对上。
    kvs := map[string]string"a": "apple", "b": "banana"
    for k, v := range kvs 
        fmt.Printf("%s -> %s\\n", k, v)
    

    //range也可以用来枚举 Unicode 字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
    for i, c := range "go" 
        fmt.Println(i, c)
    

以上实例运行输出结果为：

sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111

for循环嵌套

Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。

以下为 Go 语言嵌套循环的格式：

for [condition |  ( init; condition; increment ) | Range]

   for [condition |  ( init; condition; increment ) | Range]
   
      statement(s);
   
   statement(s);

以下实例使用循环嵌套来输出 2 到 100 间的素数：

实例

package main

import "fmt"

func main() 
   /* 定义局部变量 */
   var i, j int

   for i=2; i < 100; i++ 
      for j=2; j <= (i/j); j++ 
         if(i%j==0) 
            break; // 如果发现因子，则不是素数
         
      
      if(j > (i/j)) 
         fmt.Printf("%d  是素数\\n", i);
      
     

以上实例运行输出结果为:

2  是素数
3  是素数
5  是素数
7  是素数
11  是素数
13  是素数
17  是素数
19  是素数
23  是素数
29  是素数
31  是素数
37  是素数
41  是素数
43  是素数
47  是素数
53  是素数
59  是素数
61  是素数
67  是素数
71  是素数
73  是素数
79  是素数
83  是素数
89  是素数
97  是素数

break

Go 语言中 break 语句用于以下两方面：

• 用于循环语句中跳出循环，并开始执行循环之后的语句。
• break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
• 在多重循环中，可以用标号 label 标出想 break 的循环。

break 语法格式如下：

break

make & map函数

make（集合）

Go语言提供的内置函数make()可以用于灵活地创建数组切片。

创建一个初始元素个数为5的数组切片，元素初始值为0：

mySlice1 := make([]int, 5)

创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：

mySlice2 := make([]int, 5, 10) 

也可以选择是否在创建时指定该map的初始存储能力，创建了一个初始存储能力为100的map.

myMap = map[string] PersonInfo 
  "1234": PersonInfo"1", "Jack", "Room 101,...", 
 

创建并初始化map的代码.

map（范围）

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type

/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

package main

import "fmt"

func main() 
    var countryCapitalMap map[string]string /*创建集合 */
    countryCapitalMap = make(map[string]string)

    /* map插入key - value对,各个国家对应的首都 */
    countryCapitalMap [ "France" ] = "巴黎"
    countryCapitalMap [ "Italy" ] = "罗马"
    countryCapitalMap [ "Japan" ] = "东京"
    countryCapitalMap [ "India " ] = "新德里"

    /*使用键输出地图值 */
    for country := range countryCapitalMap 
        fmt.Println(country, "首都是", countryCapitalMap [country])
    

    /*查看元素在集合中是否存在 */
    capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
    /*fmt.Println(capital) */
    /*fmt.Println(ok) */
    if (ok) 
        fmt.Println("American 的首都是", capital)
     else 
        fmt.Println("American 的首都不存在")
    

以上实例运行结果为：

France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India  首都是 新德里
American 的首都不存在

delete() 函数

delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：

实例

package main

import "fmt"

func main() 
        /* 创建map */
        countryCapitalMap := map[string]string"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"

        fmt.Println("原始地图")

        /* 打印地图 */
        for country := range countryCapitalMap 
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        

        /*删除元素*/ delete(countryCapitalMap, "France")
        fmt.Println("法国条目被删除")

        fmt.Println("删除元素后地图")

        /*打印地图*/
        for country := range countryCapitalMap 
                fmt.Println(country, "首都是", countryCapitalMap [ country ])
        

以上实例运行结果为：

原始地图
India 首都是 New delhi
France 首都是 Paris
Italy 首都是 Rome
Japan 首都是 Tokyo
法国条目被删除
删除元素后地图
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi

Go语言函数

函数定义

函数是基本的代码块，用于执行一个任务。

Go 语言最少有个 main() 函数。

你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数声明告诉了编译器函数的名称，返回类型，和参数。

Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。

Go 语言函数定义格式如下：

func function_name( [parameter list] ) [return_types] 
   函数体

函数定义解析：

• func：函数由 func 开始声明
• function_name：函数名称，参数列表和返回值类型构成了函数签名。
• parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
• return_types：返回类型，函数返回一列值。
• return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
  函数体：函数定义的代码集合。

以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：

/* 函数返回两个数的最大值 */
func max(num1, num2 int) int 
   /* 声明局部变量 */
   var result int

   if (num1 > num2) 
      result = num1
    else 
      result = num2
   
   return result

函数调用

当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。

调用函数，向函数传递参数，并返回值，例如：

package main

import "fmt"

func main() 
   /* 定义局部变量 */
   var a int = 100
   var b int = 200
   var ret int

   /* 调用函数并返回最大值 */
   ret = max(a, b)

   fmt.Printf( "最大值是 : %d\\n", ret )


/* 函数返回两个数的最大值 */
func max(num1, num2 int) int 
   /* 定义局部变量 */
   var result int

   if (num1 > num2) 
      result = num1
    else 
      result = num2
   
   return result

以上实例在 main() 函数中调用 max（）函数，执行结果为：

最大值是 : 200

函数返回多个值

Go 函数可以返回多个值，例如：

实例

package main

import "fmt"

func swap(x, y string) (string, string) 
   return y, x


func main() 
   a, b := swap("Google", "Runoob")
   fmt.Println(a, b)

以上实例执行结果为：

Runoob Google

Go语言函数值传递值

传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。

Go语言函数引用传递值

引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

以下我们通过使用引用传递来调用 swap() 函数：

package main

import "fmt"

func main() 
   /* 定义局部变量 */
   var a int = 100
   var b int= 200

   fmt.Printf("交换前，a 的值 : %d\\n", a )
   fmt.Printf("交换前，b 的值 : %d\\n", b )

   /* 调用 swap() 函数
   * &a 指向 a 指针，a 变量的地址
   * &b 指向 b 指针，b 变量的地址
   */
   swap(&a, &b)

   fmt.Printf("交换后，a 的值 : %d\\n", a )
   fmt.Printf("交换后，b 的值 : %d\\n", b )


func swap(x *int, y *int) 
   var temp int
   temp = *x    /* 保存 x 地址上的值 */
   *x = *y      /* 将 y 值赋给 x */
   *y = temp    /* 将 temp 值赋给 y */

以上代码执行结果为：

交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100

Go语言函数作为实参

Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。以下实例中我们在定义的函数中初始化一个变量，该函数仅仅是为了使用内置函数 math.sqrt()，实例为：

package main

import (
   "fmt"
   "math"
)

func main()

   /* 声明函数变量 */
   getSquareRoot := func(x float64) float64 
      return math.Sqrt(x)
   

   /* 使用函数 */
   fmt.Println(getSquareRoot(9))

以上代码执行结果为：

3