C语言函数,解析Json文件绘制Chart

第5章 函数

 

第5章 函数
1. 函数
2. 变量的作用域
1. 局部变量
2. 全局变量
3. 变量的存储方式
小结

 

字符串: C#中$的用法: 是为了替代string.format();

图片 1

1. 函数

  1. 从函数定义的角度看,函数可分为库函数和用户自定义函数两种
    1) 库函数:由C系统提供,只需在程序前包含有该函数原型的头文件即可在程序中直接调用
    2) 用户自定义函数:由用户按需要写的函数,不仅在程序中定义函数本身,而且在主调函数模块中还必须对该被调用函数进行类型说明,然后使用
  2. 从函数兼有其它语言中的函数和过程的两个功能,又可分为有返回值函数和无返回值函数
    1) 有返回值函数:此类函数被调用执行完后将向调用者返回一个执行结果,称为函数返回值;由用户定义的这种要返回值得函数,必须在函数定义和函数说明中明确返回值的类型
    2) 无返回函数:此类函数在完成特定的处理任务,执行完成后不向调用者返回函数值。由于函数无须返回值,用户定义此类函数时可指定她的返回为"空类型(void)"
  3. 从主调函数和被调函数之间数据传送的角度可分为无参函数和有参函数
    1) 无参函数:函数定义、函数说明及函数调用中均不带参数。主调函数和被调函数之间不进行参数传送。可以返回或不返回函数值
    2) 有参函数:在函数定义及函数说明时都有参数,称为形式参数(形参)。在函数调用时也必须给出参数,称为实际参数(实参)。进行函数调用时,主调函数将把实参的值传送给形参,供被函数使用
  4. 函数定义的一般形式
    1) 无参函数的一般形式

<wiz_code_mirror>

 

 

 

 

 

1 类型说明符 函数名(){
2     类型说明
3     语句
4 }

 

 

 

其中类型说明符和函数名称为函数头。 类型说明符指明了本函数的类型,函数的类型实际上是函数返回值的类型。函数名是由用户定义的标识符,函数名后有一个空括号,其中无参数,但括号不可少。{} 中的内容称为函数体。在函数体中也有类型说明, 这是对函数体内部所用到的变量的类型说明。在很多情况下都不要求无参函数有返回值void
2) 有参函数的一般形式

<wiz_code_mirror>

 

 

 

 

 

1 类型说明符 函数名(形式参数表)
2     形式参数类型说明
3     {
4     类型说明
5     语句
6     }

 

 

 

其一是形式参数表, 其二是形式参数类型说明。在形参表中给出的参数称为形式参数, 它们可以是各种类型的变量,必须给以类型说明, 各参数之间用逗号间隔。在进行函数调用时,主调函数将赋予这些形式参数实际的值

  1. 函数的参数:分为形参和实参;形参出现在函数定义中,在整个函数体内都可以使用, 离开该函数则不能使用。实参出现在主调函数中,进入被调函数后,实参变量也不能使用,功能是作数据传送。发生函数调用时, 主调函数把实参的值传送给被调函数的形参从而实现主调函数向被调函数的数据传送
    函数的形参和实参的特点
    1) 形参变量只有在被调用时才分配内存单元,调用结束后,即刻释放所分配的内存单元。形参只有在函数内部有效,函数提哦啊用结束返回主调函数后则不能再使用该形参变量
    2) 实参可以是常量、变量、表达式、函数等,在进行函数调用时,都必须具有确定的值,以便把这些值送给形参
    3) 实参和形参在数量上、类型上、顺序上应严格一致,否则会发生“类型不匹配”的错误
    4) 函数调用中发生的数据传送是单向的,即只能把实参的值传送给形参。因此在函数调用时,形参的值发生改变,而实参中的值不会变化
  2. 函数的值:指函数被调用后,执行函数体中的程序段所取得的并返回给主调函数的值,(或称函数返回值)对函数的值的说明:
    1) 函数的值只能用过 "return 表达式" 语句返回主调函数,该语句的功能是计算表达式的值,并返回给主调函数,
    2) 函数值的类型和函数定义中函数的类型应保持一致,如果两者不一致,则以函数类型为准,自动进行类型转换
    3) 如函数值为整型,在函数定义时可以省去类型说明
    4) 不返回函数值的函数,可以明确定义为空类型 (void)
  3. 被调函数
    无参函数一般形式: 类型说明符 被调函数名()
    有参函数一般形式: 类型说明符 被调函数名(类型 形参, 类型 形参···)
  4. 函数的递归使用:一个函数在它的函数体内调用它自身称为递归调用,为了防止递归调用无终止进行,加条件判断

图片 2图片 3

2. 变量的作用域

using System.Collections.Generic;
namespace Chart
{
    public class Program
    {
        static void Main(string[] args)
        {
            Chart chart = new Chart();
            ChartType chartType = ChartType.Histogram;
            string path = @"....JSON.json";
            DataSource dataSource = new JsonDataSource();
            List<Composition> Compositions = dataSource.GetDataList(path);
            chart.Compositions.AddRange(Compositions);
            chart.Draw(chartType);
            chart.Save();
        }
    }
}

1. 局部变量

  1. 局部变量:也称为内部变量。在函数内做定义说明的。其作用域仅限于函数内,离开函数后再使用变量是违法的
    局部变量作用域说明
    1) 主函数中定义的变量也只能在主函数中使用,不能在其它函数中使用
    2) 形参变量是属于被调函数的局部变量,实参变量是属于主调函数的局部变量
    3) 允许在不同的函数中使用相同的变量名

语法糖:

Program.cs

2. 全局变量

  1. 全局变量:也称为外部变量,是在函数外部定义的变量;其作用域是整个源程序,只有在函数内经过说明的全局变量才能使用,全局变量说符为extern
    全局变量作用域说明
    1) 外部变量定义必须在所有的函数之外,且只能定义一次。一般形式: [extern] 类型说明符 变量名, 变量名··· extern int a, b
    2) 外部变量可加强函数模块之间的数据联系但会使得函数的独立性降低
    3) 在同一源文件中,允许全局变量和局部变量同名,在局部变量的作用域内,全局变量不起作用

C#6.0: 

 

3. 变量的存储方式

  1. 静态存储 和 动态存储
    静态存储变量通常是在 常量定义时就分定存储单元并一直不变,直至整个程序结束;全局变量即属于此类存储方式;
    动态存储变量是在程序执行过程中,使用它时才分配存储单元,使用完毕立即释放,函数的形式参数即属于此类存储方式
    静态存储变量是一直存在的,而动态存储变量则时有时无,对变量的存储类型说明:
auto 自动变量
register 寄存器变量
extern 外部变量
static 静态变量
  • 自动变量和寄存器变量属于动态存储方式, 外部变量和静态变量属于静态存储方式

图片 4图片 5

小结

  1. 函数的分类
    1) 库函数:由C系统提供的函数
    2) 用户定义函数:由用户自己定义的函数
    3) 有返回值的函数向调用者返回函数值,应说明函数类型(即返回值的类型)
    4) 无返回值的函数:不返回函数值,说明为空(void)类型
    5) 有参函数:主调函数向被调函数传送数据
    6) 无参函数:主调函数与被调函数无传送数据
    7) 内部函数:只能在本院文件中使用的函数
    8) 外部函数:可在整个源程序中使用的函数
  2. 函数 定义 的一般形式
    [extern/static] 类型说明符 函数名([形参表]) 方括号内为可选框
  3. 函数 说明 的一般形式
    [extern] 类型说明符 函数名 ([形参表])
  4. 函数 调用 的一般形式
    函数名 ([实参表])
  5. 函数的参数
    分为形参 和 实参,形参出现在函数定义中,实参出现在函数调用中,发生函数调用时,将把实参的值送给形参
  6. 函数的值
    指函数的返回值,是在函数中由 return 语句返回的
  7. 数组名作为函数参数
    不进行值传送而进行地址传送,形参和实参实际上为同一个数组的两个名称,因此形参和实参同时变化
  8. C语言中,允许函数的嵌套调用 和 函数的递归调用
  9. 可根据变量的数据类型、变量作用域和变量的存储类型对变量分类
  10. 变量的作用域是指变量在程序中的有效范围,分为局部变量 和 全局变量
  11. 变量的存储类型是指变量在内存中的存储方式,分为静态存储 和 动态存储,表示了变量的生存期
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Drawing;
namespace Chart
{
    public class Chart
    {
        private Bitmap bmp = new Bitmap(600, 600);
        List<Composition> composition = new List<Composition>();
        public List<Composition> Compositions { get { return composition; } }
        private float width;

        private float Width
        {
            get
            {
                int sum = 0;
                foreach (var composition in Compositions)
                {
                    sum += composition.DataPoints.Count + 1;
                }
                width = (float)420 / sum;
                return width;
            }
        }

        public void Draw(ChartType chartType)
        {
            Series series;

            switch (chartType)
            {
                case ChartType.LineChart:
                    series = new LineSeries();
                    break;

                case ChartType.Histogram:
                    series = new HistogramSeries();
                    break;

                case ChartType.PieChart:
                    series = new PieSeries();
                    break;

                default:
                    throw new ArgumentOutOfRangeException("Nonexistent ChartType!");
            }

            foreach (var comPosition in Compositions)
            {
                series.Legend.Add(comPosition.Name);
            }

            Platform platform = new Windows(bmp);

            series.Draw(Width, platform, Compositions);
        }

        public void Save()
        {
            bmp.Save(@"....1.bmp");
            Process.Start(@"....1.bmp");
        }
    }
}

Chart.cs

图片 6图片 7

using System.Collections;
using System.Collections.Generic;
using System.Drawing;
namespace Chart
{
    public abstract class Series
    {
        ArrayList legend = new ArrayList();
        public ArrayList Legend { get { return legend; } set { } }

        protected PointF PointFormLarge;
        protected PointF PointFormSmall;

        private void DrawChart(Platform g)
        {
            g.FillRectangle(g.WBrush, 20, 20, 580, 500);
        }

        protected abstract void DrawCore(float width, Platform g, List<Composition> Compositions);

        public void Draw(float width, Platform g, List<Composition> Compositions)
        {
            PointFormLarge = new PointF(width * Compositions.Count + width, 0);
            PointFormSmall = new PointF(width, 0);
            DrawChart(g);
            DrawCore(width, g, Compositions);
        }
    }
}

Series.cs

图片 8图片 9

using System.Collections.Generic;
using System.Drawing;
using System;
namespace Chart
{
    public class HistogramSeries : Series
    {

        private void DrawAxes(Platform g)
        {
            g.DrawLine(g.Rpen, new Point(100, 40), new Point(100, 420));
            g.DrawLine(g.Rpen, new Point(100, 40), new Point(90, 50));
            g.DrawLine(g.Rpen, new Point(100, 40), new Point(110, 50));
            g.DrawLine(g.Rpen, new Point(100, 420), new Point(570, 420));
            g.DrawLine(g.Rpen, new Point(570, 420), new Point(560, 410));
            g.DrawLine(g.Rpen, new Point(570, 420), new Point(560, 430));

            g.DrawString("月考成绩", g.LargeFont, g.Bbrush, new RectangleF(300, 30, 170, 50));
            g.DrawString("科目", g.LargeFont, g.Bbrush, new RectangleF(530, 450, 100, 40));
            g.DrawString("成绩", g.LargeFont, g.Bbrush, new RectangleF(40, 30, 40, 40));

            for (int i = 0; i < 5; i++)
            {
                g.DrawLine(g.BlackPen, new Point(100, 60 + 72 * i), new Point(570, 60 + 72 * i));
            }
        }

        private void DrawLegend(Platform g)
        {
            int LegendWidth = 250 / (Legend.Count - 1);
            int StringX = 50;
            int LegendX = StringX + 60;
            int k = 0;
            foreach (string legend in Legend)
            {
                switch (k)
                {
                    case 0:
                        g.Brush = Brushes.Blue;
                        break;
                    case 1:
                        g.Brush = Brushes.Red;
                        break;
                    case 2:
                        g.Brush = Brushes.Yellow;
                        break;
                    case 3:
                        g.Brush = Brushes.Green;
                        break;
                }
                g.DrawString(legend, g.LargeFont, Brushes.Blue, StringX, 480);
                Rectangle rect = new Rectangle(LegendX, 480, LegendWidth * 2 / 3, 20);
                g.FillRectangle(g.Brush, rect);

                StringX += 550 / Legend.Count;
                LegendX = StringX + 60;
                k++;
            }
        }



        protected override void DrawCore(float width, Platform g, List<Composition> Compositions)
        {
            DrawAxes(g);
            DrawLegend(g);
            foreach (var datapoint in Compositions[0].DataPoints)
            {
                g.DrawString(datapoint.XValue, g.LargeFont, g.Bbrush, 120, 430);
                g.TranslateTransform(PointFormLarge.X, PointFormLarge.Y);
            }
            g.ResetTransform();

            int YValueMax = 0;
            foreach (var composition in Compositions)
            {
                if (YValueMax <= composition.Max)
                {
                    YValueMax = composition.Max;
                }
            }

            g.YRatioScale = 370 / YValueMax;


            for (int i = 0; i <= 5; i++)
            {
                g.DrawString(Math.Ceiling(360/5/ g.YRatioScale*(5-i)).ToString(), g.LargeFont, g.BlackBrush, new RectangleF(80, 50 + 72 * i, 50, 50));
            }




            void DrawRectangle(float x, float y, float Width, float height, Composition composition)
            {
                Rectangle rect = new Rectangle((int)x, (int)y, (int)width, (int)height);
                g.FillRectangle(composition.BrushColor, rect);
            }
            int j = 1;
            foreach (var composition in Compositions)
            {
                Compositions[0].BrushColor = Brushes.Blue;
                Compositions[1].BrushColor = Brushes.Red;
                Compositions[2].BrushColor = Brushes.Yellow;
                foreach (var datapoint in composition.DataPoints)
                {
                    DrawRectangle(120, 420 - datapoint.YValue * g.YRatioScale, width, datapoint.YValue * g.YRatioScale, composition);
                    g.DrawString(datapoint.YValue.ToString(), g.SmallFont, Brushes.Red, 120, 420 - datapoint.YValue * g.YRatioScale - 15);
                    g.TranslateTransform(PointFormLarge.X, PointFormLarge.Y);
                }
                g.ResetTransform();
                for (int i = 0; i < j; i++)
                {
                    g.TranslateTransform(PointFormSmall.X, PointFormSmall.Y);
                }
                j++;
            }
            g.ResetTransform();
        }
    }
}

本文由澳门新葡亰平台官网发布于编程,转载请注明出处:C语言函数,解析Json文件绘制Chart

TAG标签:
Ctrl+D 将本页面保存为书签,全面了解最新资讯,方便快捷。