C语言函数详解

已于 2024-10-04 20:37:57 修改
阅读量884 收藏 10
点赞数 13
文章标签： c语言 开发语言 笔记
于 2024-09-24 00:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63040946/article/details/142466149
版权

[C语言函数详解

C语言数组详解

C语言操作符详解

C语言初阶指针详解

C语言结构体详解

文章目录

函数

一、函数的参数

1、实参（实际参数）

  • 真实传给函数的参数，叫实参。

  • 实参可以是： 常量、变量、表达式、函数等。

  • 无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。

2、形参（形式参数）

  • 形式参数是指函数名后括号中的变量，因为形式参数只有在函数被调用的过程中才实例化（分配内存单元），所以叫形式参数。

  • 形式参数当函数调用完成之后就自动销毁了。因此形式参数只在函数中有效。

3、示例
  1. 使用函数求两个数中的较大值
int get_max(int a, int b)
{
	//int max = 0;
	//if (a >= b)return a;
	//else return b;
	return(a > b ? a : b);
}
int main()
{
	int a = 0;
	int b = 0;
	while (1)
	{	
		scanf("%d %d", &a, &b);
		int max = get_max(a, b);
		printf("较大的是：%d\n", max);
	}
	return 0;
}

  • 输出：

  •   23 65
  较大的是：65
  1. 使用函数交换两个整形变量的内容
// 形参
//void Exchange(int x, int y)
//{
//	int Temp = x;
//	x = y;
//	y = Temp;
//}
//实参传递给形参时，形参会拷贝一份实参的内容，而并不会改变实参
void Exchange(int* x, int* y)
{
	int Temp = *x;
	*x = *y;
	*y = Temp;
}
int main()
{
	int a = 0;
	int b = 0;
	while (1)
	{	
		scanf("%d %d", &a, &b);
		printf("交换前A=%d B=%d\n", a, b);
		//Exchange(a, b); //a,b为实参
		Exchange(&a, &b);
		printf("交换后A=%d B=%d\n", a, b);
	}
	return 0;
}

  • 输出：

  •   22 66
  交换前A=22 B=66
  交换后A=66 B=22
    • 实参传递给形参时，形参会拷贝一份实参的内容，而并不会改变实参

二、函数的调用

1、传值调用
  • 函数的形参和实参分别占有不同内存块，对形参的修改不会影响实参。
2、传指调用

  • 传址调用是把函数外部创建变量的内存地址传递给函数参数的一种调用函数的方式。

  • 这种传参方式可以让函数和函数外边的变量建立起正真的联系，也就是函数内部可以直接操作函数外部的变量。

eg1、使用函数实现质数的判断
  • 质数又称素数。一个大于1的自然数，除了1和它自身外，不能被其他自然数整除的数叫做质数；否则称为合数（规定1既不是质数也不是合数）。
#include <stdio.h>
//使用函数判断一个数是不是素数（质数）
#include <math.h>
//sqrt()开平方，返回值为double类型
int Prime(int A)
{
	int i = 0;
	for (i = 2; i <= (int)sqrt(A); i++)
	{
		if (A % i == 0)
		{
			return 0;//不是质数
		}
	}
	return 1;//是质数
}
int main()
{
	int a = 0;
	while (1)
	{
		scanf("%d", &a);
		if (Prime(a) == 1)
			printf("%d->是质数\n", a);
		else printf("%d->不是质数\n", a);
	}
	return 0;
}

输出：

3
3->是质数
4
4->不是质数
5
5->是质数
6
6->不是质数
sqrt()的使用

doubel sqrt(double A)

  • 包含在头文件include <math.h>中

  • 返回值是其中参数的开平方（double类型）

eg2、利用函数打印1000 - 2000年之间的闰年
#include <stdio.h>
//打印1000-2000年之间的闰年
//闰年：1、能被四整除且不能被100整除；2、能被100整除
int main()
{
	int i = 0;
	for (i = 1000; i <= 2000; i++)
	{
		if (((i % 4 == 0) && (i % 100 != 0)) || (i % 400 == 0))
		{
			printf("%d ", i);
		}
	}
	return 0;
}

输出：

1004 1008 1012 1016 1020 1024 1028 1032 1036 1040 1044 1048 1052 1056 1060 1064 1068 1072 1076 1080 1084 1088 1092 1096 1104 1108 1112 1116 1120 1124 1128 1132 1136 1140 1144 1148 1152 1156 1160 1164 1168 1172 1176 1180 1184 1188 1192 1196 1200 1204 1208 1212 1216 1220 1224 1228 1232 1236 1240 1244 1248 1252 1256 1260 1264 1268 1272 1276 1280 1284 1288 1292 1296 1304 1308 1312 1316 1320 1324 1328 1332 1336 1340 1344 1348 1352 1356 1360 1364 1368 1372 1376 1380 1384 1388 1392 1396 1404 1408 1412 1416 1420 1424 1428 1432 1436 1440 1444 1448 1452 1456 1460 1464 1468 1472 1476 1480 1484 1488 1492 1496 1504 1508 1512 1516 1520 1524 1528 1532 1536 1540 1544 1548 1552 1556 1560 1564 1568 1572 1576 1580 1584 1588 1592 1596 1600 1604 1608 1612 1616 1620 1624 1628 1632 1636 1640 1644 1648 1652 1656 1660 1664 1668 1672 1676 1680 1684 1688 1692 1696 1704 1708 1712 1716 1720 1724 1728 1732 1736 1740 1744 1748 1752 1756 1760 1764 1768 1772 1776 1780 1784 1788 1792 1796 1804 1808 1812 1816 1820 1824 1828 1832 1836 1840 1844 1848 1852 1856 1860 1864 1868 1872 1876 1880 1884 1888 1892 1896 1904 1908 1912 1916 1920 1924 1928 1932 1936 1940 1944 1948 1952 1956 1960 1964 1968 1972 1976 1980 1984 1988 1992 1996 2000

使用函数：

#include <stdio.h>
//利用函数打印1000 - 2000年之间的闰年
int Get_Leap_Year(int year)
{
	//是闰年返回1
	//不是闰年返回0
	if (((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0))
		return 1;
	else 
		return 0;
}
int main()
{
	int i = 0;
	for (i = 1000; i <= 2000; i++)
	{
		if(Get_Leap_Year(i))
			printf("%d ", i);		
	}
	return 0;
}

输出：

1004 1008 1012 1016 1020 1024 1028 1032 1036 1040 1044 1048 1052 1056 1060 1064 1068 1072 1076 1080 1084 1088 1092 1096 1104 1108 1112 1116 1120 1124 1128 1132 1136 1140 1144 1148 1152 1156 1160 1164 1168 1172 1176 1180 1184 1188 1192 1196 1200 1204 1208 1212 1216 1220 1224 1228 1232 1236 1240 1244 1248 1252 1256 1260 1264 1268 1272 1276 1280 1284 1288 1292 1296 1304 1308 1312 1316 1320 1324 1328 1332 1336 1340 1344 1348 1352 1356 1360 1364 1368 1372 1376 1380 1384 1388 1392 1396 1404 1408 1412 1416 1420 1424 1428 1432 1436 1440 1444 1448 1452 1456 1460 1464 1468 1472 1476 1480 1484 1488 1492 1496 1504 1508 1512 1516 1520 1524 1528 1532 1536 1540 1544 1548 1552 1556 1560 1564 1568 1572 1576 1580 1584 1588 1592 1596 1600 1604 1608 1612 1616 1620 1624 1628 1632 1636 1640 1644 1648 1652 1656 1660 1664 1668 1672 1676 1680 1684 1688 1692 1696 1704 1708 1712 1716 1720 1724 1728 1732 1736 1740 1744 1748 1752 1756 1760 1764 1768 1772 1776 1780 1784 1788 1792 1796 1804 1808 1812 1816 1820 1824 1828 1832 1836 1840 1844 1848 1852 1856 1860 1864 1868 1872 1876 1880 1884 1888 1892 1896 1904 1908 1912 1916 1920 1924 1928 1932 1936 1940 1944 1948 1952 1956 1960 1964 1968 1972 1976 1980 1984 1988 1992 1996 2000
eg3、函数实现整形有序数组的二分查找
#include <stdio.h>
//函数实现整形有序数组的二分查找
int Search_Array(int *arr, int a, int sz)
{
	int left = 0;
	int right = sz - 1;
  //找到了返回下标
  //找不到返回-1（数组第一个元素下标为0）
	while (left <= right)
	{
		int mid = left + (right - left) / 2;
		if (arr[mid] > a)
			right = mid - 1;
		else if (arr[mid] < a)
			left = mid + 1;
		else
			return mid;
	}
	return -1;
}
int main()
{
	int arr[] = { 1,3,4,6,7,8,9,10,11,12,13,15,16,17,19,20 };
	int a = 6;
	int sz = sizeof(arr) / sizeof(arr[0]);
	int Sub = Search_Array(arr, a, sz);
	if (Sub == -1)
		printf("数组中没有这个数\n");
	else
		printf("%d在数组中的下标是%d\n", a, Sub);
	return 0;
}

输出：

6在数组中的下标是3

三、函数的嵌套调用和链式访问

1、函数的嵌套调用

函数的嵌套调用

void pr1()
{
	printf("***********\n");
}
void pr2()
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		pr1();
	}
}
int main()
{
	pr2();
	return 0;
}

  • 输出：

  •   ***********
  ***********
  ***********
  ***********
  ***********

函数可以嵌套调用但是不能嵌套定义

嵌套定义：❌❌❌

void pr2()
{
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		void pr1()//嵌套定义Err
 		{
			printf("***********\n");
 		}
	}
}
int main()
{
	pr2();
	return 0;
}

无法运行！！！

2、函数的链式访问

一个函数的返回值可以作为其它函数的参数

int main()
{
	printf("%d", printf("%d", printf("%d", 43)));
	return 0;
}

  • 输出结果：

  •   4321
printf()的返回值

printf()返回打印的字符数，如果发生错误，则返回负值。

四、函数的声明和定义

在C语言中，函数的声明和定义是两个不同的概念，它们在不同的文件中或同一文件的不同部分进行。

#include <stdio.h>

int add(int a, int b);//函数的声明

int main()
{
	int a = 10;
	int b = 20;
	printf("%d", add(a, b));

	return 0;
}

int add(int a, int b)//函数的定义
{
	return (a + b);
}

  •   30

1、函数声明

  • 函数声明告诉编译器函数的名称、返回类型、参数类型和数量（不包含函数体的实现代码）。

  • 函数声明通常放在头文件中或在需要调用函数之前进行声明。要满足先声明后使用

示例：

int add(int a, int b);

这里，add 是函数名，int 是返回类型，括号中的 int a, int b 是参数列表。

2、函数定义

函数定义包括函数的实现代码。它包含了函数体，即函数执行的具体操作。

示例：

int add(int a, int b) 
{
    return (a + b);
}

这里，add是函数名，int是返回类型，括号中的 int a, int b是参数列表，大括号{}内是函数体，包含返回语句 return a + b;

3、函数声明与定义的关系

  • 函数声明：告诉编译器函数的存在和参数类型，但不提供实现。
  • 函数定义：提供函数的具体实现。
函数声明的位置

通常将函数声明放在头文件中，这样其他文件可以通过包含这个头文件来知道函数的存在和参数类型。

示例：

// file: add.h
#ifndef ADD_H
#define ADD_H

int add(int a, int b);

#endif

  • 使用静态库时的.h文件

  •   #pragma once//防止头文件被重复包含
  #pragma comment(lib,"add.lib")//导入静态库
  
  
  int Add(int a, int b);//函数的声明

然后在需要使用这个函数的文件中包含这个头文件：

// file: main.c
#include <stdio.h>
#include "add.h"

int main() 
{
    int result = add(3, 4);
    printf("Result: %d\n", result);
    return 0;
}
函数定义的位置

函数定义通常放在源文件中，例如 .c 文件。

示例：

// file: add.c
#include "add.h"

int add(int a, int b) 
{
    return a + b;
}

这样，通过编译这些文件，编译器会将它们链接在一起，形成一个完整的程序。

五、函数递归

  • 递归是一种编程技术，一个函数直接或间接地调用自己。

  • 递归函数可以用于解决许多问题，特别是那些可以分解为相似子问题的问题。

  • 递归通常用于实现分治算法、深度搜索、树的遍历等。

1、递归函数的特点

  1. 基本条件：递归函数必须有一个或多个基本条件（也称为终止条件），当满足这些条件时，函数将停止递归调用。
  2. 递归步骤：除了基本条件外，函数还需要包含递归调用，即函数调用自身的代码。
  3. 返回值：递归函数通常需要返回一个值，这个值可以是递归调用的结果。
  4. 每次递归调用之后会越来越接近限制条件。

2、递归的工作原理

递归函数通过不断调用自己来解决问题。每次调用都会将问题分解为更小的子问题，直到满足基本条件，然后逐步返回结果。（大事化小）

3、注意事项

  1. 避免无限递归：确保递归函数有一个明确的终止条件，否则会导致无限递归。
  2. 栈溢出：递归调用会消耗内存栈空间，如果递归深度过大，可能会导致栈溢出。
eg1、使用递归，接收一个整形值，按照顺序打印它的每一位
//使用递归
//接收一个整形值，按照顺序打印它的每一位
//例如：输入1234；输出4 3 2 1

void print(unsigned int num)//n=1234
{
	if (num > 9)
	{
		print(num / 10);//123
	}printf("%d ", num % 10);//4
}
int main()
{
	unsigned int num = 0;
	scanf("%u", &num);//%u是输入无符号整形
	print(num);
	return 0;
}

//print(1234)
//print(123) 4
//print(12) 3 4
//print(1) 2 3 4

  • 输出：

  •   1234
  1 2 3 4

请添加图片描述

eg2、模拟实现strlen()，返回字符串个数
  • 使用临时变量
//模拟实现strlen()，返回字符串个数

//int my_strlen(char str[])//参数部分写成指针的形式
int my_strlen(char str[])  //参数部分写成数组的形式
{
	int count = 0;//计数，使用临时变量
	while (*str != '\0')
	{
		count++;
		str++;//找下一个字符
	}
	return count;
}
int main()
{
	char str[] = "abcd";//[a b c d \0]
	printf("%d", my_strlen(str));
	return 0;
}

  • 输出：

  •   4

  • 使用递归，不创建临时变量

//不创建临时变量使用递归
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str + 1);
	else
		return 0;
}
int main()
{
	char str[] = "abcd";//[a b c d \0]
	printf("%d", my_strlen(str));
	return 0;
}

  • 输出：

  •   4

请添加图片描述

strcmp()比较字符串

  • 包含于<string.h>头文件中

  • 用于判断两个 字符串（字符数组） 是否相等

  • 使用方法

    • 若strcmp(字符串1,字符串2) == 0，则字符串1与字符串2相等，反之则不相等

getchar()返回ASCII码

getchar()函数实际上是int getchar(void)，所以它返回的是ASCII码

int main()
{
	char ch;
	printf("请输入字符：");//1 2 3 回车
	scanf("%c", &ch);// 读取 1
	printf("%c", getchar());// 读取并输出 2
	printf("%c", getchar());// 读取并输出 3
	printf("%c", getchar());// 读取并输出 回车
}
  • getchar()可以用来处理\n

3、递归与迭代

  1. 斐波那契数列问题
  2. 汉诺塔问题
  3. 青蛙跳台阶问题

1. 求n!（n的阶乘）

  • 使用递归求n!

  •   //使用递归求n!
  int fac(int n)
  {
  	//if (n > 0)
  	//	return (n * fac(n - 1));
  	//else
  	//	return 1;
  
  	if (n <= 1)
  		return 1;
  	else
  		return n * fac(n - 1);
  }
  int main()
  {
  	int n = 0;
  	while (1)
  	{
  		scanf("%d", &n);
  		printf("%d!=%d\n", n, fac(n));
  	}	
  	return 0;
  }

    • 输出：

    •   3
  3!=6
  4
  4!=24
  5
  5!=120

  • 使用迭代求n!（非递归）

  •   //使用迭代求n！
  int fac(int n)
  {
  	int dev = 1;
  	while(n > 0)
  	{
  		dev *= n;
  		n--;
  	}
  	return dev;
  }
  int main()
  {
  	int n = 0;
  	while (1)
  	{
  		scanf("%d", &n);
  		printf("%d!=%d\n", n, fac(n));
  	}
  	return 0;
  }

    • 输出：

    •   4
  4!=24
  5
  5!=120
  6
  6!=720

2. 求第n个斐波那契数（Fibonacci sequence）

斐波那契数列又称黄金分割数列（兔子数列）是指这样一个数列： 1，1，2，3，5，8，13，21，34，55，89……这个数列从第3项开始 ，每一项都等于前两项之和。

  • 使用递归

  •   //求第n个斐波那契数（Fibonacci sequence）
  /斐波那契数列（兔子数列）是指这样一个数列：
   1，1，2，3，5，8，13，21，34，55，89……
   这个数列从第3项开始 ，每一项都等于前两项之和。*/
  int fibona(int n)
  {
  	if (n <= 2)
  		return 1;
  	else
  		return fibona(n - 1) + fibona(n - 2);
  }
  //20
  //19          18
  //18    17    17    16
  //17 16 16 15 16 15 15 14
  //......
  int main()
  {
  	int n = 0;
  	while (1)
  	{
  		scanf("%d", &n);
  		printf("第%d个斐波那契数是：%d\n", n, fibona(n));
  	}
  	return 0;
  }

    • 输出：

    •   5
  第5个斐波那契数是：5
  6
  第6个斐波那契数是：8
  7
  第7个斐波那契数是：13
  8
  第8个斐波那契数是：21
  9
  第9个斐波那契数是：34

    • 缺点： 使用递归来求斐波那契数列效率很低，随着n的增加，所需要计算的次数也在指数级增长

      20
19          18
18    17    17    16
17 16 16 15 16 15 15 14
......

  • 使用迭代

  •   //迭代
  int fibona(int n)
  {
  	int n1 = 1;
  	int n2 = 1;
  	int seq = 0;
  	if (n <= 2)
  		return 1;
  	while (n >= 3)
  	{
  		seq = n1 + n2;
  		n2 = n1;
  		n1 = seq;
  		n--;
  	}
  	return seq;
  }
  int main()
  {
  	int n = 0;
  	while (1)
  	{
  		scanf("%d", &n);
  		printf("第%d个斐波那契数是：%d\n", n, fibona(n));
  	}
  	return 0;
  }

    • 输出：

    •   10
  第10个斐波那契数是：55
  11
  第11个斐波那契数是：89
  12
  第12个斐波那契数是：144
  13
  第13个斐波那契数是：233
  14
  第14个斐波那契数是：377
隼玉
关注
C语言-指针函数
hxy1625309592的博客
05-28 223
函数参数 普通变量作为函数的参数 代码示例 #include <stdio.h> // 声明函数 void ChangeNumValue(int a) { a = 10000; } int main() { // 定义变量 int num = 10; // 调用函数 ChangeNumValue(num); printf("num = %d\n", num); return 0; } 图示 程序运行结果 num = 10 指针变量作
VC软件开发规范（参数、返回值以及函数内部实现规则）
www 关注互联网最新技术
05-30 2016
4.1 参数的规则 ☆ 【规则4.1-1】 参数的书写要完整，不要贪图省事只写参数的类型而省略参数名字，如果函数没有参数，则用void填充；例如： void SetValue(int nWidth, int nHeight); // 良好的风格 void SetValue(int, int);               // 不良的风格 float GetValue(void);                  // 良好的风格 float GetValue();               
VC获取主函数参数
诣
02-17 1698
网上寻他千百度，手指一抖，那厮（_wtoi）却在犄角旮旯处。 int _tmain(int argc, _TCHAR* argv[]) 这是VC（VS2005）里面的主函数，看惯了Linux和VC6下面的main，再看这个_tmain很不顺眼。VC的编译会根据你的设置（默认设置我这里是Unicode版本），把_tmain变成wmain（针对Unicode版本，w是wide的意思，Unicode
形参与实参的区别
qq_44320708的博客
10-31 1643
实参(argument)：   全称为"实际参数"是在调用时传递给函数的参数. 实参可以是常量、变量、表达式、函数等， 无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值， 以便把这些值传送给形参。 因此应预先用赋值，输入等办法使实参获得确定值。       形参(parameter)： 全称为"形式参...
C语言函数(2)--形参与实参的讲解与函数的调用
weixin_69283129的博客
07-15 1万+
C语言函数的形参实参之间的区别，函数的调用
c语言函数大全及详解 -供大家学习研究参考
11-13
函数原型说明 功能 返回值 说明 int abs( int x) 求整数x的绝对值 计算结果 double fabs(double x) 求双精度实数x的绝对值 计算结果 double acos(double x) 计算cos-1(x)的值 ...
C语言函数详解大全
11-06
"C语言函数详解大全"是一个针对C语言函数的全面参考资料，它包含了C语言开发过程中可能用到的所有函数，每个函数都有详尽的功能解释、使用方法以及示例代码，是学习和查阅C语言函数的宝贵资源。 C语言中的函数是...
C语言 回调函数详解
01-20
回调函数在C语言编程中是一种重要的机制，尤其在处理复杂逻辑和抽象接口时。回调函数的概念基于函数指针，即一个指向函数的指针。在C语言中，每个函数都有其在内存中的地址，函数指针就是存储这个地址的变量，从而...
形参和实参的区别
热门推荐
小默的博客
12-17 9万+
形参和实参的区别
实参和形参的区别
qq_43992721的博客
01-25 5134
实参和形参的区别 形参：函数定义时的参数，可以看作是一个占位符，没有数据，只有在函数调用时候会接受传递进来的数据 实参：调用函数时使用的参数，具有真实的数据，实参的值会传递给形参 区别： 1.形参只有在调用的时候才会分配内存，调用结束后就会释放内存，因此只在函数内部有作用 2.形参没有具体的值、实参在进行函数调用的时候必须有确定的值传递给形参，它们的数据传送是单向的 3.实参和形参在函数调用的
C/C++中函数参数传递详解
yidi
03-09 1957
昨天看了内存管理的有关内容，有一点了解，但不是很深入，发现之前写代码时有很多细节问题没有注意到，只知道这样做可以实现功能，却不知道为什么可以这样，对于采用自己的方法造成的隐患也未知，更不晓得还有其他方法可以实现，我们知道C++强大的一个原因是因为对于一个问题的答案多种解答方法或思路，我想着也许就是它难学的原因。因为你只知道一种或极少数的实现方法，却不知道其他的实现方法，换句话说，就是对这个东西很掌
函数的初步学习
最新发布
2401_87396735的博客
09-26 212
例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。提示：以下是本篇文章正文内容，下面案例可供参考初步了解了函数与函数的运用，但关于函数的算法还不是很懂，特别是Hanoi塔的问题。
C++ 函数形参和实参的区别
分享嵌入式,移动端,智能应用,数据库等专业板块,记录知识碎片！！！
02-05 875
一.形参出现在函数定义的地方，实参出现在函数调用的地方 二.形参可以包含0，1，多个参数，实参数量与形参数量一样 三.形参规定一个函数接受的数据类型和数量， 四.实参主要作用是初始化形参，并且是一一对应的，必须与对应的形参类型匹配 五.形参决定了形参和实参的交互方式，如果形参是引用类型，则它将绑定到实参上，否则实参将拷贝赋值给形参 ...
C++浅拷贝和深拷贝的区别
weixin_30908707的博客
02-27 332
c++默认的拷贝构造函数是浅拷贝 浅拷贝就是对象的数据成员之间的简单赋值，如你设计了一个没有类而没有提供它的复制构造函数，当用该类的一个对象去给令一个对象赋值时所执行的过程就是浅拷贝，如：class A { public: A(int _data) : data(_data){} A(){}private: int data; };int main() { A a(5), b = a;...
获取命令行参数的各种变化
逍遥骏马
04-18 2519
http://blog.csdn.net/silvergingko/article/details/6072083 通常，在VC++中获取命令行参数的有如下几种方式:   在控制台程序中： C++运行时库通过入口函数main传递进来的参数int argc 和 char* argv[]。其中第二个参数将一个完整的命令行分割成指向各参数的字符串指针数组，数组中的每一个元素是
指针作为函数参数在C/C++中调试和探讨
木木
01-27 4083
通过一道码农常遇到的问题但是并未去深入分析过的问题，一步一步的调试跟踪截图来分析，问题出在哪里，怎么解决和理解，来帮助消化知识点：函数传值和传指针的相同。函数传递时仅仅是传递的值。借用一位网友的总结： “函数的参数进行值拷贝,即使传的是指针,也的对指针(即指针里存的地址)的拷贝。” 遇到搞不清楚的时候勤动手，多调试，肯定会搞明白的。
实参跟形参的区别
Timothy的博客
01-08 563
实参跟形参的区别 参数 : 实际参数 : 就是实际参加运算的值 , 基本数据类型就是值, 引用数据类型是地址值 形式参数 : 定在在方法上, 用来表示接收的数据的类型 形式参数会影响栈中的基本数据类型的值，但无法改变堆中引用数据类型中的地址值； ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值