函数

最新推荐文章于 2023-03-03 01:36:15 发布
最新推荐文章于 2023-03-03 01:36:15 发布
阅读量172 收藏
点赞数
文章标签： 数据结构与算法 嵌入式 c/c++
原文链接：http://www.cnblogs.com/noticeable/p/9314285.html
版权

　　函数是程序的基本组成单位，利用函数，不仅能够实现程序的模块化，而且简单、直观，能极大的提高程序的易读性及可维护性，所以将程序中的一些计算或操作抽象成函数以供谁是调用，理解函数的执行原理以及应用是一个优秀程序员应该具备的基本能力。

1、怎么样写一个接受可变参数的函数

　　C语言支持函数调用的参数为变参形式。例如，printf()这个函数，它的函数原型是int printf(const char* format,...)，它除了有一个参数format固定以外，后面跟的参数的个数和类型都是可变的，可以有以下多种不同的调用方法：

1、printf("%d",i );
2、printf("%s",s);
3、printf("the number is %d,string is %s",i,s);

　　printf函数是一个有着变参的库函数，在C语言中，也可以更具实际的需求编写变参函数，示例如下：

#include "stdafx.h"
#include<stdio.h>

int add2(char num, ...)
{
	int sum = 0;
	int index = 0;
	int *p = NULL;
	p = (int *)&num + 1;
	for (; index < (int)num; ++index)
	{
		sum += *p++;
	}
	return sum;
}
int main()
{
	int i = 1;
	int j = 2;
	int k = 3;
	printf("%d\n", add2(3, i, j, k));
	return 0;
}

　　运行结果如下：

2、函数指针和指针函数有什么区别

　　指针函数是指带指针的函数，本质上是一个函数，函数返回类型是某一类型的指针。其形式一般如下：

类型标识符 *函数名（参数列表）

　　例如，int *f(x,y)，它的意思是声明一个函数f(x,y),该函数返回类型为int型指针。

　　而函数指针是指想函数的指针变量，即本质是一个指针变量，表示的是一个指针，它指向的是一个函数。其形式一般如下：

类型说明符 （*函数名)(参数)

　　例如，int (*pf)(int x),它的意思就是声明一个函数指针，而pf=func则是将func函数的首地址赋值给指针。下面是一个相关示例：

#include "stdafx.h"
#include<stdio.h>

#define NULL 0
#define ASGN 1
#define MUL 2

int asgn(int*a, int b)
{
	return *a = b;
}
int mul(int*a, int b)
{
	return *a*b;
}
int(*func(int op))(int*, int)
{
	switch (op)
	{
		case ASGN:
			return &asgn;
		case MUL:
			return &mul;
		default:
			return NULL;
	}
	return NULL;
}

int main()
{
	int i = 0xFEED, j = 0xBEEF;
	printf("%x\n", func(ASGN)(&i, j));
	printf("%x\n", func(MUL)(&i, j));
	printf("%x,%x\n", i, j);
		return 0;

}

　　程序运行结果如下：

 

 

引申：数组指针/指针数组、函数模板/模板函数、类模板/模板类、指针常量/常量指针分别有什么区别？

（1）数组指针/指针数组

　　数组指针就是指向数组的指针，他表示的是一个指针，它指向的是一个数组，他的重点是指针。例如，int (*pa)[8]声明了一个指针，该指针指向了一个有8个int型元素的数组。

#include "stdafx.h"
#include<stdio.h>

int main()
{
	int(*p)[4];
	int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
	p = &a[0];
	for (int i = 0; i < 12; i++)
		printf("%d", (*p)[i]);
	printf("\n");
	return 0;
}

　　运行结果如下：

　　指针数组就是指针的数组，表示的是一个数组，它包含的元素是指针，它的重点是数组。

例如，int* ap[8]声明了一个数组，该数组的每一个元素都是int型的指针。

#include "stdafx.h"
#include<stdio.h>

int main()
{
	int* p[4];
	int a[4] = { 1,2,3,4 };
	p[0] = &a[0];
	p[1] = &a[1];
	p[2] = &a[2];
	p[3] = &a[3];
	for (int i = 0; i < 4; i++)
		printf("%d", *p[i]);
	printf("\n");
	return 0;
}

　　程序运行结果如下：

（2）函数模板/模板函数

　　函数模板是对一批模样相同的函数的说明描述，它不是某一个具体的函数；而模板函数则是将函数模板内的“数据类型参数”具体化后得到的重载函数（就是由模板而来的函数）。简单的说，函数模板是抽象的，而模板函数是具体的。

　　函数模板减少了程序员输入代码的工作量，是C++中功能最强的特性之一，是提高软件代码重用性的重要手段之一。函数模板的形式一般如下：

template<模板函数形参表>
<返回值类型><函数名>（模板模板形参表)
{
    //函数体
}

　　其中<模板含形参表>的，包括基本数据类型和类类型。需要注意到的是，函数模板并不是一个实实在在的函数，它是一组函数的描述，并不能直接执行，需要示例化为模板函数后才能执行，而一旦数据类型形参实例化以后，就会产生一个实实在在的模板函数了。

　　

（3）模板类/类模板

 　　类模板和函数模板类似，将数据类型定义为参数，描述了代码类似的部分类的集合，具体化为模板类后，可以用于生成具体的对象。

template<类型参数表>
class<类名>
{
    //类说明体
};

template <类型形参表>
<返回类型><类名><类型名表>::<成员函数1>(形参表)
{
//成员函数定义体
}

　　其中<类型形参表>与函数模板<类型形参表>意义雷氏，而类模板本身不是一个真实的类，只是对类的一种描述，必须用类型参数将其实例化为模板类后，才能用来生成具体的对象。简而言之，类是对象的抽象，而类模板就是类的抽象。

　　具体而言，C++中引入模板类主要由以下5个方面的好处：

  1. 可用来创建动态增长和减小的数据结构。
  2. 它是类型无关的，因此具有很高的可复用性。
  3. 它在编译时而不是运行时检查数据类型，保证了类型安全。
  4. 它是与平台无关的，可移植性强。
  5. 可用于基本数据类型。

（4）指针常量/常量指针

　　指针常量是指定义的指针只能在定义的时候初始化，之后不能改变其值。其格式为：

[数据类型][*][const][指针常量名称]
例如：
char * const p1;
int* const  p2;

　　const位于指针声明符“*”的右侧，这说明声明的对象是一个常量，而对象的数据类型是指针。所以第一句定义了一个只读的字符型指针p1；第二局定义了一个只读型的整形指针p2。常指针的值不能改变，但是其指向的内容却可以改变。

　　

#include "stdafx.h"
#include<stdio.h>

int main()
{
	char a[5] = "abcd";
	char b[5] = "efgh";
	char * const p1 = a;
	char * const p2 = b;
	printf("Before Change:\n");
	printf("a:%s\nb:%s\n", a, b);
	*p1 = '1';
	b[0] = '2';
	//p1=p2;
	printf("After Change:\n");
	printf("a:%s\nb:%s\n", a, b);
	return 0;
}

　　运行结果如下：

　　上例中，如果去掉注释行，执行p1=p2操作，则会编译出错。指针所指向的内存地址不能更改，指针的值只能在定义的时候初始化，其他地方不能更改。

 

常量指针是指向常量的的指针，因为常量指针指向的对象是常量，因此这个对象的值不能够改变的。定义的格式如下：

[数据类型][const][*]{常量指针对象];
或
[const][数据类型][*]{常量指针名称];

例如：
int const *p;const int *p;

　　程序示例如下：

#include "stdafx.h"
#include<stdio.h>

int main()
{
	char a[5] = "abcd";
	char b[5] = "efgh";
	const char *  p1 = a;
	const char *  p2 = b;
	printf("Before Change:\n");
	printf("a:%s\nb:%s\n", a, b);
	a[0] = '1';
	p1=p2;
　　　　//*p2='2';
	printf("After Change:\n");
	printf("a:%s\nb:%s\n", a, b);
	return 0;
}

　　运行结果如下：

 

　　 上例中，注释部分错误，不能给常量赋值。

　　需要注意的是，指针常量强调的是指针的不可改变性，而常量指针强调的是针对其所指对象的不可改变性，它所指向的对象的值是不能通过常量来改变的。对于字符串“abc”，可以这样获取地址：&（”abc“）。

 

3、C++函数传递参数的方式有哪些

　　当金星函数调用时，要填入与函数形式参数个数相同的实际参数，在程序运行过程中，实际参数就会将参数传递给相应的形式参数，然后在函数中实现对数据的处理和返回。C++函数传递参数的方式一般由以下4种：

（1）值传递：值传递就是将实参的值复制到形参中。程序示例如下：

#include "stdafx.h"
#include<iostream>

using namespace std;

void swap(int a, int b)
{
	int temp;
	temp = a;
	a = b;
	b = temp;
	cout << a << "," << b << ednl;
}

int main()
{
	int x = 1;
	int y = 2;
	swap(x, y);
	cout << x << "," << y << endl;
	return 0;
}

　　程序运行结果如下

（2）指针传递:指针传递，进行指针传递时，形参是指针变量，实参是一个变量的地址，调用函数时，形参指向实参变量单元。示例如下：

#include "stdafx.h"
#include<iostream>

using namespace std;

void swap(int *a, int *b)
{
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
	cout << *a << "," << *b << endl;
}

int main()
{
	int x = 1;
	int y = 2;
	swap(&x, &y);
	cout << x << "," << y << endl;
	return 0;
}

　　

（3）传引用：实参地址传递到形参，使形参的地址去实参的地址，从而使形参与实参共享同一单元的方式。示例代码如下：

#include "stdafx.h"
#include<iostream>

using namespace std;

void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    cout << a << "," << b << endl;
}

int main()
{
    int x = 1;
    int y = 2;
    swap(x, y);
    cout << x << "," << y << endl;
    return 0;
}

运行结果为：

（4）全局变量传递

 

4、重载与覆盖有什么区别

　　重载是指函数不同的参数表，对同名函数的名称做修饰，然后这些同名函数就成了不同的函数。在同一个可访问区域内被声明的几个具有不同参数列（参数的类型、个数、顺序不同）的同名函数，程序会根据不同的参数列来确定具体调用哪个函数。对于重载函数的调用，在编译期间就已经确定，是静态的，它们的地址在编译期间就绑定了与多态无关。重载不关心函数的返回值类型。

（1）double calculate(double);
（2）double calculate(double,double);
（3）double calculate(double,int);
（4）double calculate(int,double);
（5）double calculate(int);
（6）float calculate(double);
（7）float calculate(float);

　　7个同名函数calculate，1，2，3，4，5，6，中任意两个均构成重载，6，7也能构成重载，而1，7不能构成重载，因为1，7的参数相同。

 

　　成员函数被重载的特征如下：

  1. 相同的范围
  2. 函数名相同
  3. 参数不同
  4. virtual关键字可有可无。

覆盖是指派生类中存在重新定义基类的函数，其函数名、参数列、返回值类型必须同父类中的相对应被覆盖的函数严格一致，覆盖函数和比覆盖函数只有函数体不同，当派生类对象调用子类中该同名函数时会自动调用子类中的覆盖版本，而不是父类中的被覆盖函数版本，它和多态真正相关。当子类重新定义了父类的虚函数后，父类指针根据赋给它的不同的子类指针，动态的调用属于子类的该函数，这样的哈是你地址是在运行期绑定的。

　　覆盖的特征如下：

  1. 不同的范围。
  2. 函数名字相同
  3. 参数相同
  4. 基类函数必须由virutal关键字。

　重载和覆盖的区别如下：

  1. 覆盖是子类和父类之间的关系，是垂直关系；重载是同一类中方法之间的关系，是水平关系。
  2. 覆盖只能由一个方法，或只能由一对方法产生关系；方法的重载是多个方法之间的关系。
  3. 覆盖要求参数列表相同；重载要求参数列表不同。
  4. 覆盖关系中，调用方法体是根据对象的类型（对象对应存储空间类型）来决定的，重载关系是根据调用时的实参表与形参表来选择方法体的。

程序示例如下：

 

#include "stdafx.h"
#include<iostream>

using namespace std;

class Base
{
public:
	void f(int x)
	{
		cout << "Base::f(int)" << x << endl;
	}
	void f(float x)
	{
		cout << "Base::f(float)" << x << endl;
	}
	virtual void g(void)
	{
		cout << "Base::g(void)" << endl;
	}
};
class Derived :public Base
{
public:
	virtual void g(void)
	{
		cout << "Derived::g(void)" << endl;
	}
};
int main()
{
	Derived d;
	Base *pb = &d;
	pb->f(42);
	pb->f(3.14f);
	pb->g();
	return 0;
}

　　程序运行结果如下：

　　上例中，函数Base::f(int)与Base::f(float)相互重载，而Base::g(void)被Derived::g(void)覆盖。

 

隐藏是之派生类的函数与基类的函数同名，规则如下：

  1. 如果派生类的函数与基类的函数同名，但是参数不同，则无论有无virutal关键字，基类的函数都被隐藏。
  2. 如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字，此时基类的函数被隐藏。

在调用一个类的成员函数是，编译器会沿着类的集成连逐级的向上查找函数的定义，如果找到了就停止查找。所以，如果一个派生类和一个基类都存在同名（不管参数）的函数，而编译器最终选择了派生类中的函数，那么就说这个派生类的成员函数“隐藏”了基类的成员函数，也就是说它阻止了编译器继续向上查找函数的定义。

回到隐藏的定义，前面已经说了有virtual关键字，并且派生类函数与基类函数同名，同参数函数构成覆盖的关系，因此隐藏的关系只有如下的可能：

  1. 必须分别位于派生类和基类中
  2. 必须同名
  3. 参数不同的时候本身已经不构成覆盖关系了，所以此时是否有virtual已经不重要了。

　　当参数相同的时候就要看是否有virtual关键字了，有的话就是覆盖关系，没有的时候就是隐藏关系。示例如下：

#include "stdafx.h"
#include<iostream>

using namespace std;

class Base
{
public:
	virtual void f(float x)
	{
		cout << "Base::f(float)" << x << endl;
	}
	 void g(float x)
	{
		cout << "Base::g(float)" <<x<< endl;
	}
	void h(float x)
	{
		cout << "Base::h(float)" <<x<< endl;
	}
};
class Derived :public Base
{
public:
	virtual void f(float x)
	{
		cout << "Derived::f(float)" << x << endl;
	}
	void g(float x)
	{
		cout << "Derived::g(int)" << x << endl;
	}
	void h(float x)
	{
		cout << "Derived::h(float)" << x << endl;
	}
};
int main()
{
	Derived d;
	Base *pb = &d;
	Derived *pd = &d;
	pb->f(3.14f);
	pd->f(3.14f);
	pb->g(3.14f);
	pd->h(3.14f);

	return 0;
}

　运行结果如下：Derived::f(float)覆盖了Base::f(float)，函数Derived::g(int)隐藏了Base::g(float)而不是重载，Derived::h(float)隐藏了Base::h(float)而不是覆盖。

 

 

5、是否可以通过绝对内存地址进行参数的赋值与函数的调用

　　同一个数可以通过不同的方式表达出来，对于函数的访问，变量的赋值除了直接对变量赋值以外，还可以通过绝对内存地址进行参数赋值和函数调用。

  1. 通过地址修改变量的值

    #include "stdafx.h"
    #include<iostream>
    int main()
    {
    int x;
    int *p;
    printf("%x\n", &x);
    p = &x;
    *p = 3;
    printf("%d\n", x);
    }

    　　程序输出结果为

    • 通过地址调用函数的执行

 

#include "stdafx.h"
#include<iostream>

using namespace std;

typedef void(*FuncPtr)();

void p()
{
	static int i = 0;
	i++;//每调用一次+1
	printf("%d\n",i);
}

int main()
{
	void(*ptr)();
	p();//第一次调用ptr函数指针
	printf("%x\n", p);//输出函数的入口地址
	ptr = (void(*)())&p;//将指针ptr指向函数的入口地址
	ptr();//调用ptr
	((void(*)())&p)();//不通过函数指针，直接通过地址调用
	((FuncPtr)&p);//最后通过typedef调用直接执行。
	return 0;
}

　　运行结果如下：

　　函数名称、代码都是放在代码段的，因为放在代码段，每次都会跳到相同的地方，但参数会压栈，所以函数只根据函数名来获取入口地址，与参数和返回值无关。无论参数和返回值如何不同，函数入口地址都是一个地方。

#include "stdafx.h"
#include<iostream>
#include<stdio.h>	

int p(int a, int b)
{
	return((a > b) ? a : b);
}

int main()
{
	int(*ptr)(int, int);
	printf("%x\n", p);
	ptr = (int(*)(int, int))&p;
	int c = ptr(5, 6);//通过函数指针调用有返回值的参数，不使用函数名，而是用函数入口地址调用。
	printf("%x\n", ptr);
	printf("%d\n", c);
	return 0;

}

　　程序运行结果如下：

 

6、默认构造函数是否可以调用单参数构造函数

　　默认构造函数不可以调用单参数的构造函数。

 

 

7、C++中函数调用有哪几种方式

　　编译器一般使用堆栈实现函数调用。堆栈是存储器的一个区域，嵌入式环境有时需要自己定义一个数组作为堆栈。Windows为每个线程自动维护一个堆栈，堆栈的大小可以设置。编译器使用堆栈来存放每个函数的参数、局部变量等等信息。

　　由于函数调用经常会被嵌套，在同一时刻，堆栈中会存储多个函数的信息，每个函数又占用一个连续的区域，一个函数占用的区域常被称为帧，编译器是从高地址开始使用堆栈的，在多线程（任务）环境，CPU的堆栈指针指向的存储器区域就是当前使用的堆栈。切换线程是一个重要的工作，就是将堆栈指针设置为当前线程的堆栈栈顶地址。不同CPU，不同编译期的堆栈布局、函数调用方法都可能不同，但堆栈的基本概念是一样的。

　　当一个函数被调用时，进程内核对象为其在进程的地址空间的堆栈部分分配一定的栈内存给该函数使用，函数堆栈功能如下：

  1. 在进入函数之前，保存“返回地址”和环境变量。返回地址是指该函数结束后，从进入该函数之前的那个地址继续执行下去。
  2. 在进入函数之后，保存实参或实参复制、局部变量。

　　函数原型:[连接规范]函数类型[调用约定]函数名 参数列表{...}

　　调用约定：调用约定是决定函数实参或实参复制进入和退出函数堆栈的方式以及函数堆栈释放的方式，简单来讲就是实参或实参复制入栈、出栈、函数堆栈释放的方式。在Win32下有以下4种调用：

  1. _cdecl:C/C++的默认调用方式。实参是以列表从右依次向左入栈 ，出栈相反。函数堆栈由调用方来释放，主要用在那些带有可变参数的函数上，对于传送参数的内存栈是由调用者来维护的，另外，在函数名修饰约定方面也有所不同。由于每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。
  2. _stdcall:它是win api的调用约定，其实COM接口等只要是申明定义接口都要显示指定其调用约定为_stdcall。实参以参数列表从由依次向左入栈，出栈相反。函数堆栈是由被调用方自己释放的。但是若函数含有可变参数，那么即使显示指定了_stdcall，编译器也会自动将其改变成_cdecall.
  3. _thiscall:它是类的非静态成员函数默认的调用约定，其不能用在含有可变参数的函数上，否则会编译出错。实参以参数列表从右一次向左入栈，出栈相反。函数堆栈是由被调用方自己释放的。但是类的非静态成员函数内部都隐含由一个this指针，该指针不是存放在函数堆栈上，而是直接存放在CPU寄存器上。
  4. _fastcall:快速调用。它们的实参并不是存放在函数堆栈上，而是直接存放在CPU寄存器上，所以不存在入栈、出栈、函数堆栈释放。

需要注意到的是，全局函数或类静态成员函数，若没有指定调用，约定默认是_cdecl或是IDE设置的。

 

8、什么是可重入函数？C语言如何编写可重入函数

　　可重入函数是指能够被多个线程“同时”调用的函数，并且能保证函数结果正确性的函数。

　　在C语言种编写可重入函数时，尽量不要使用全局变量或静态变量，如果使用了全局变量或静态变量，就需要特别注意对这类变量访问的互斥。一般采用以下几种措施来保证函数的可重入性：信号量机制、关调度机制、关中断机制等方式。

　　需要注意的是，不要调用不可重写的函数，当调用了不可重入的函数时，会使该函数也变为不可重入的函数。一般驱动程序都是不可重写的函数，因此在编写驱动程序时一定要注意重入的问题。

转载于:https://www.cnblogs.com/noticeable/p/9314285.html

weixin_33708432
关注
函数指针/函数指针数组
weixin_42162393的博客
08-06 121
函数指针 int(*func)(int,int);
C++中函数指针的使用
热门推荐
sruru的专栏
08-28 6万+
在C/C++中存在着函数指针，即指向函数的指针。我目前已知的两种使用方法是：    #include #include typedef int* PINNT; #define PP int* int funcA(int a,int b); int funcB(int* a,int *b); int main(int argc, char *argv[]) { int (*func)
C/C++ 函数指针
Expressing Youself Using Code
04-21 2115
函数声明例如：float func(int, int); 以上就是一个函数的声明，要注意他的实际功能并没有被实现，换句话说就是他并没有被定义，只是声明次函数的存在。float func(int,int); 说明func(int,int)是一个float，func是函数地址（特别注意，他不是指针，而是函数在内存中的地址），它可以接受两个int型的数据作为传入参数。如果你要使用声明的函数，你就必须对这个
C语言之数组与指针
NANYOSTAR
09-28 736
*******数组首元素的地址 vs 数组首地址******* /* a: bff0660c a+1: bff06610 &a: bff0660c &a+1: bff06620 */ int a[5] = {1,2,3,4,5}; printf("a: %x\n", a); //address of first element in the array printf("a+1
C++ 学习记录3
figure1996的博客
03-04 296
十 引用（reference） 4 引用型函数参数 1）可以将引用用于函数的参数，这时形参就是实参的别名，可以通过形参直接修饰实参，同时还可以避免参数传递的过程，减小函数的调用开销，提高代码的执行效率 2）引用型参数可能会以外修改实参，如果不希望修改实参，可以将形参声明为常引用，提高传參效率的同时还可以接收常量型的实参。 5 引用型函数返回值 1）可以将函数的返回类型声明为引用，避免函数返回值所带...
YOLOv5｜YOLOv7｜YOLOv8改各种IoU损失函数：YOLOv8涨点Trick，改进添加SIoU损失函数、EIoU损失函数、GIoU损失函数、α-IoU损失函数-CSDN博客.mhtml
最新发布
10-23
YOLOv5｜YOLOv7｜YOLOv8改各种IoU损失函数：YOLOv8涨点Trick，改进添加SIoU损失函数、EIoU损失函数、GIoU损失函数、α-IoU损失函数-CSDN博客.mhtml
MATLAB仿真画出OFDM雷达信号的模糊函数图像
06-01
利用MATLAB仿真画出OFDM雷达信号的模糊函数图像。 具体理论分析参见笔者博客 https://blog.csdn.net/qq_46084757/article/details/125089683?spm=1001.2014.3001.5501
Java 8函数式编程.pdf
08-12
Java 8函数式编程
高斯函数及其反函数求法
04-19
高斯函数+二分法求反函数，，，程序设计导论——————Python语言实现，课本习题。
实变函数论(第2版)周民强 最高清 完整
03-04
普通高等教育“九五”教育部重点教材，是为综合大学、理工科大学、高等师范院校数学系、应用数学系本科生编写的“实变函数”课程教材，主要介绍Lebesgue测度与积分理论、共分六章：集合与点集，Lebesgue测度,可测...
C++之虚函数表
maoliran的博客
06-16 557
虚函数是C++实现多态的一种重要方式，那么虚函数是如果进行工作的，这就依赖于虚函数表，虚函数表是对象生成时自动生成的，当对象释放时，虚函数表也会自动消失，这一切对程序员都是透明的。class Base { public: virtual void f(){cout << "Base::f()" << endl;} virtual void g(){cout << "Base::g()
C/C++ 函数指针 总结
聚精会神搞建设
08-06 6643
什么是函数指针 就像某一变量的地址可以存储在相应的指针变量中一样，指向函数的指针中保存着函数代码起始处的地址 函数指针的声明 当声明一个函数指针时，必须声明它指向的函数类型。要指定函数类型，就要指出函数的返回类型和参数列表，如： void (* pf)(int, int); //pf是一个函数指针，它指向的函数类型为：返回值为void，参数列表为(int, int)
C语言指针进阶（二）——再谈指针、函数、数组复杂的三叉戟关系
MIss-Y的博客
11-18 1160
前言：前面有一篇文章是专门针对函数指针与指针函数的，本文再进一步说明指针，涉及到两个较为复杂烦琐的概念，即 函数指针数组、函数指针数组的指针。前一篇文章参考为： C语言指针进阶（一）——深入详解“函数指针”与“指针函数” 一、函数指针数组 前面的文章已经详细介绍了函数指针，它是如何定义的也已经很清楚了，那究竟什么是函数指针数组呢？ 1.1 案例一 先从一个案例来说明，比如我有四个函...
C语言再学习22——指针&数组（七）
霁风AI
11-05 366
前言： 为了方便查看博客，特意申请了一个公众号，附上二维码，有兴趣的朋友可以关注，和我一起讨论学习，一起享受技术，一起成长。 1. 函数指针的定义 函数的指针，它是一个指针，指向一个函数。 举例： A：char *(*func1)(char *p1,char *p2); B：char * *func2(char *p1,char *p2); C：char *func3(char *p1,c...
Java研发类岗位笔试题（基础）
weixin_45947614的博客
03-03 991
一些简单的Java笔试题
第6章 继承和接口设计
cat marshal的博客
06-20 2275
一．选择题 1．在C#中，一个类【 D 】。 A) 可以继承多个类 B) 可以实现多个接口 C) 在一个程序中只能有一个子类 D) 只能实现一个接口 2．【 D 】关键字用于在C#中从派生类中访问基类的成员。 A) new B) super C) this D) base 3．在定义类时，若希望类的某个方法能够在派生类中进一步改进，以满足派生类的不同需要，则...
[C/C++] 多线程
胖胖的ALEX
08-13 2811
概念 多线程（英文：multithreading）多线程程序包含了可以并发运行的两个或更多个程序部分。这样程序中的每个部分称为一个线程，并且每个线程都定义了一个单独的执行路径 std::thread类 官方文档 1. 最简单的线程 void foo() { // do something... } thread t1(foo); t1.join(); thread t2(fo...
实用经验 82 区分overloading、overriding、hiding的差异
一鸣惊人的博客
09-09 284
OOP存在重载（overloading）、重写（overriding）、隐藏（hiding）3个概念。他们非常相似，也容易混淆。三者的差异可从作用域，函数名，参数，返回值，有无virtual等方面来理解。
重载java_方法重载
weixin_30122219的博客
02-19 190
1、方法重载/*方法重载我们将名字相同，参数列表不同的两个(或多个)方法称为重载方法。参数列表的不同体现在以下两点：1 参数的类型不同2 参数的个数不同方法参数列表的不同，是编译器用来区分调用哪一个重载方法的依据。*/public class Overload {public void f(int x) {System.out.println("f(int x)");}public void f(...
C语言函数详解
函数 函数是C语言程序设计中的一种基本结构单元，用于实现具体的功能。函数可以将大段的程序代码按照功能分解开，体现出对重复使用的程序段的抽象。 函数的定义形式有两种：无参函数和有参函数。无参函数的定义...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值