c# 结构体作为函数参数

2016-03-23 19:24:35 sun172270102 阅读数 2556

结构体作为参数传递的错误!
如下代码:定义了一个结构体变量,将该结构体变量作为参数传递给函数func2,此时传递给函数func2的是结构体变量my_sis的拷贝,函数func2中对所传入的结构体的修改不影响main函数中定义的结构体,所修改的只是传入的拷贝的副本。


  1#include <stdio.h>
  2 
  3 struct score
  4 {
  5         int math;
  6         int english;
  7 };
  8 
  9 struct stu
 10 {
 11         int age;
 12         struct score core;
 13 };
 14 
 15 void fun(int b[5])
 16 {
 17         b[3]=8;
 18 }
 19 void fun2(struct stu my)
 20 {
 21         my.core.math = 100;
 22 }
 23 
 24 int main()
 25 {
 26         //int a[5]={1,2,3,4,5};
 27         struct stu my_sis;
 28 
 29         my_sis.core.math = 10;
 30         my_sis.core.english = 50;
 31 
 32         /*
 33         fun(a);
 34         printf("%d\n",a[3]);
 35         */
 36         fun2(my_sis);
 37         printf("%d\n",my_sis.core.math);
 38 
 39 }


2017-01-04 15:47:00 daxi0315 阅读数 83

    将一个结构体变量中的数据传递给另一个函数,有下列3种方法:

  1. 用结构体变量名作参数。一般较少用这种方法。
  2. 用指向结构体变量的指针作实参,将结构体变量的地址传给形参。
  3. 用结构体变量的引用变量作函数参数。

   下面通过一个简单的例子来说明,并对它们进行比较。

  有一个结构体变量stu,内含学生学号、姓名和3门课的成绩。要求在main函数中为各成员赋值,在另一函数print中将它们的值输出。

 

 1) 用结构体变量作函数参数。

  

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 struct Student//声明结构体类型Student
 5 {
 6    int num;
 7    char name[20];
 8    float score[3];
 9 };
10 int main( )
11 {
12    void print(Student); //函数声明,形参类型为结构体Student
13    Student stu; //定义结构体变量               
14    stu.num=12345; //以下5行对结构体变量各成员赋值
15    stu.name="Li Fung";
16    stu.score[0]=67.5;
17    stu.score[1]=89;
18    stu.score[2]=78.5;
19    print(stu); //调用print函数,输出stu各成员的值
20    return 0;
21 }
22 void print(Student st)
23 {
24    cout<<st.num<<" "<<st.name<<" "<<st.score[0]
25    <<" " <<st.score[1]<<" "<<st.score[2]<<endl;
26 }

 

  2)用指向结构体变量的指针作实参在上面程序的基础上稍作修改即可。

  

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 struct Student
 5 {
 6    int num; string name; //用string类型定义字符串变量
 7    float score[3];
 8 }stu={12345,"Li Fung",67.5,89,78.5}; //定义结构体student变量stu并赋初值
 9 int main( )
10 {
11    void print(Student *); //函数声明,形参为指向Student类型数据的指针变量
12    Student *pt=&stu; //定义基类型为Student的指针变量pt,并指向stu
13    print(pt); //实参为指向Student类数据的指针变量
14    return 0;
15 }
16 
17 //定义函数,形参p是基类型为Student的指针变量
18 void print(Student *p)
19 {
20    cout<<p->num<<" "<<p->name<<" "<<p->score[0]<<" " <<
21    p->score[1]<<" "<<p->score[2]<<endl;
22 }

 

  调用print函数时,实参指针变量pt将stu的起始地址传送给形参p(p也是基类型为student的指针变量)。这样形参p也就指向stu

在print函数中输出p所指向的结构体变量的各个成员值,它们也就是stu的成员值。在main函数中也可以不定义指针变量pt,而在调用print函数时以&stu作为实参,把stu的起始地址传给实参p。

 

 3) 用结构体变量的引用作函数参数

 1 #include <iostream>
 2 #include <string>
 3 using namespace std;
 4 struct Student
 5 {
 6    int num;
 7    string name;
 8    float score[3];
 9 }stu={12345,"Li Li",67.5,89,78.5};
10 
11 int main( )
12 {
13    void print(Student &);
14    //函数声明,形参为Student类型变量的引用
15    print(stu);
16    //实参为结构体Student变量
17    return 0;
18 }
19 
20 //函数定义,形参为结构体Student变量的引用
21 void print(Student &stud)
22 {
23    cout<<stud.num<<" "<<stud.name<<" "<<stud.score[0]
24    <<" " <<stud.score[1]<<" "<<stud.score[2]<<endl;
25 }

 

程序(1)用结构体变量作实参和形参,程序直观易懂,效率是不高的。
程序(2)采用指针变量作为实参和形参,空间和时间的开销都很小,效率较高。但程序(2)不如程序(1)那样直接。
程序(3)的实参是结构体Student类型变量,而形参用Student类型的引用,虚实结合时传递的是stu的地址,因而效率较高。它兼有(1)和(2)的优点。

 

转载于:https://www.cnblogs.com/wyuzl/p/6248952.html

2019-06-21 13:45:48 weixin_42274148 阅读数 685
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Threading.Tasks;

//json
using System.Web.Script.Serialization;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System.Data.SqlClient;

namespace csharpTest
{
    /// <summary>
    /// class program类
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            int x = 5;
            int y = 6;
            swap(ref x, ref y);
            Console.WriteLine(x);
            Console.WriteLine(y);
            Console.ReadLine();
        }

        static public void swap(ref int x, ref int y)
        {
            int temp;
            temp = x;
            x = y;
            y = temp;
        }
    }
}

 

2013-05-13 22:52:52 heisedelangzi 阅读数 1792

把结构体作为参数传递 

1.对于我来这样是很难理解的。结构体名不像数组名那样是这块内存块的地址。当用结构体指针做参数的时候。就应该用&来取出该结构体的地址,

才能使用。

2.当把就够体名作为参数的时候。如 

#include <stdio.h>

struct name funds {   /*建立结构体*/

char bank[10];

     cahr name1[10];

...........

}stan;  /*定义结构体变量

double sum (struct funds moolah)  ;   /*函数声明*/

 int main (void)

{

   ....结构体初始化......

double sum (struct  funds stan); /*函数调用*/

    ......................;

 return 0;

}

double sum (struct funds moolah)  /*代码读到这里,sum( ) 会利用funds模板创建一个自动变量moolah,然后结构体成员被初始化为stan结构的相应的成员取值的副本*/

{

........

}

2010-05-11 10:26:00 onlyou930 阅读数 12270

     C#中结构都有一个默认的不带参数的构造函数, 用于对结构的字段进行初始化,并且结构的默认构造函数不能被重写。

     C#结构体构造函数之中定义的数组还可以通过构造函数传参数进行初始化操作!

     1和2的作用相同,但是用2的方式定义的话需要选中 “项目属性/生成/允许不安全代码"。

     以下是来自MSDN

     结构与类共享大多数相同的语法,但结构比类受到的限制更多

     在结构声明中,除非字段被声明为 const 或 static,否则无法初始化。

     结构不能声明默认构造函数(没有参数的构造函数)或析构函数。 
     由于结构的副本由编译器自动创建和销毁,因此不需要使用默认构造函数和析构函数。实际上,编译器通过为所有字段赋予默认值(参见默认值表(C# 参考))来实现默认构造函数。结构不能从类或其他结构继承。

     结构是值类型。如果从结构创建一个对象并将该对象赋给某个变量,则该变量包含结构的全部值。复制包含结构的变量时,将复制所有数据,对新副本所做的任何修改都不会改变旧副本的数据。由于结构不使用引用,因此结构没有标识;无法区分具有相同数据的两个值类型实例。C#结构体构造函数 中的所有值类型都继承自 ValueType,后者继承自 Object。

     结构具有以下特点:

     结构是值类型,而类是引用类型。

     与类不同,结构的实例化可以不使用 new 运算符。

     结构可以声明构造函数,但它们必须带参数。

     一个结构不能从另一个结构或类继承,而且不能作为一个类的基。所有结构都直接继承自 System.ValueType,后者继承自 System.Object。

     结构可以实现接口。

     C#结构体构造函数可用作可为 null 的类型,因而可向其赋 null 值。