C++可调用Callable类型的总结

转自：高性能架构探索

自从在使用 std::thread 构造函数过程中遇到了 Callable 类型的概念以来用到了很多关于它的使用.
因此本文把使用/调查结果总结出来. 包括 Callable 的基础概念, 典型的 Callable 类型介绍.
例如函数对象(狭义), 函数指针, lambda 匿名函数, 函数适配器, std::function 仿函数等.

Callable 类型

基础

• 定义(参考):可调用(Callable) 类型是可应用 INVOKE 操作(std::invoke 是在 C++17 里定义的类, 感觉意思就是执行函数操作的模板类.)

• 要求:一个 T 类型要满足为 callable 需要以下表达式在不求值语境中良构.INVOKE(f, [std::declval]ArgTypes>()...) 即 INVOKE(f, t1, t2, ..., tN).其中 f 为 T 类型的对象, ArgTypes 为适合的实参类型列表, R 为适合的返回类型.R为 void 的时可以表示为 static_cast(INVOKE(f, t1, t2, ..., tN)).

• 详细地

1. 若 f 是类 T 的成员函数指针: 上面等价于 (t1.*f)(t2, ..., tN) 或者 t1 是指针时 ((*t1).*f)(t2, ..., tN).

2. 若 N == 1 且 f 是类 T 的数据成员指针: INVOKE(f, t1) 等价于 t1.*f, 或者指针形式 (*t1).*f.

3. 均不满足上面的情况表明 f 是一个函数对象(Function Object) : INVOKE(f, t1, t2, ..., tN) 等价于 f(t1, t2, ..., tN).

同时, 对于成员函数指针和数据成员指针, t1 可以是一个常规指针或一个重载了 operator* 的类的对象, 例如智能指针 std::unique_ptr 或 std::shared_ptr.

可作为参数的标准库

下列标准库设施接受任何可调用(Callable)类型:

库	说明
function(C++11)	包装具有指定函数调用签名的任意_可复制构造类型_的可调用对象 (类模板)
bind(C++11)	绑定一或多个实参到函数对象 (函数模板)
reference_wrapper(C++11)	可复制构造 (CopyConstructible)且可复制赋值 (CopyAssignable)的引用包装器 (类模板)
result_of (C++11)(C++20 中移除) invoke_result(C++17)	推导以一组实参调用一个可调用对象的结果类型 (类模板)
thread (构造函数)	构造新的 thread 对象 (std::thread 的公开成员函数)
call_once(C++11)	仅调用函数一次, 即使从多个线程调用 (函数模板)
async(C++11)	异步运行一个函数(有可能在新线程中执行),并返回保有其结果的 std::future(函数模板)
packaged_task(C++11)	打包一个函数, 存储其返回值以进行异步获取 (类模板)

一些典型的 Callable 类型

函数对象 Function Object

一个重载了括号操作符()的对象, 也就是可以以f(args)形式进行函数调用的对象.

#include
#include
using namespace std;
class Add {
public:
    const int operator()(const int a,const int b){
        return a+b;}
};

int main() {
    Add addFunction; //函数对象
    cout<

	 

	我的第一印象是它跟函数指针有什么区别? 就像是个函数执行包装器, 一个对象型的函数指针?

	但是函数对象本质上还是一个 class 的具体化 object, 里面是可以附带一些成员变量(可以理解为函数对象的状态(state))的, 这就让函数对象的应用场景比函数指针更广阔. 最典型的便是 STL 里了. C++ 的 STL 中的众多 algorithm, 非常依赖于函数对象处理容器的元素. 想按照 STL 算法里的要求实现其功能要提供一些函数对象作为参数, 即谓词参数(predicate). 例如对于 find_if 算法.

	 
class NoLess{
public:
    NoLess(int min = 0):m_min(min){}
    bool operator() (int value) const{
        return value >= m_min;}
private:
    int m_min;
};

find_if(dest.begin(),dest.end(),NoLess(10));  //dest容器里找是否存在不小于10的元素

	 

	对于普通函数来说, 只要签名一致, 其类型就是相同的, 是类型不安全的. 但是这并不适用于函数对象, 因为函数对象的类型是其类的类型. 这样, 函数对象有自己的类型, 这也意味着函数对象可以用于模板参数, 这对泛型编程有很大提升. 因为函数对象一般用于模板参数, 模板一般会在编译时会做一些优化. 因此函数对象一般快于普通函数. 类也可以在使用的时候动态再产生, 节省成本.

	既然是类, 那就有它的限制, 例如要注意, 如同其他所有对象(狭义上的对象, 我感觉内置类型其实也可以被叫对象, 按场景区分吧)一样, 如果 pass-by-value 的化, 对象里的成员变量是被复制进去的, 一旦对象被析构了, 里面的成员变量也是无法保存下来的. 所以可以 pass-by-reference/pointer.

	函数指针并不是没有其用处了, 对于 C API 库里的某些函数不支持函数对象还是有用武之地的. 例如  里面的排序函数 qsort 只能调用函数指针.

	 
void qsort( void *ptr, size_t count, size_t size,int (*comp)(const void *, const void *) );

	 

	函数

	除了普通的函数, 当然也包括类成员函数.

	这里不提及模板函数, 因为模板函数的概念只存在于编译期, 运行期的函数没有模板的概念, 都是经过完全特化过的, 因此与普通函数/类成员函数的概念是一致的.

	函数指针

	 
#include
#include
using namespace std;
int AddFunc(int a, int b)  {  
    return a + b;}  

int main() {
    int (*Add1) (int a, int b); //函数指针,函数名两侧的()不可省略
    int (*Add2) (int a, int b);
    Add1 = &AddFunc;
    Add2 = AddFunc;       
    cout << (*Add1) (3, 2)<

	 

	Lambda 匿名函数(调用对象)

	好处是就地定义使用, 简洁, 易维护.

	基本形式

	完整声明:

	 
[capture list] (params list) mutable exception-> return type { function body }

	 

	各项具体含义如下

	1. capture list: 捕获外部变量列表.

	2. params list: 形参列表.

	3. mutable指示符: 用来说用是否可以修改捕获的变量, 因为lambda的() operator() 默认是 const 的.

	4. exception: 异常设定.

	5. return type: 返回类型, 允许省略 lambda 表达式的返回值定义.

	6. function body: 函数体.

	捕获形式:

				捕获形式
			
				说明
		

				[]
			
				不捕获任何外部变量
		

				[变量名, …]
			
				默认以值得形式捕获指定的多个外部变量(用逗号分隔), 如果引用捕获, 需要显示声明(使用 & 说明符)
		

				[this]
			
				以值的形式捕获 this 指针
		

				[=]
			
				以值的形式捕获所有外部变量
		

				[&]
			
				以引用形式捕获所有外部变量
		

				[=, &x]
			
				变量x以引用形式捕获,其余变量以传值形式捕获
		

				[&, x]
			
				变量x以值的形式捕获,其余变量以引用形式捕获
		

	省略其中的某些成分来声明”不完整”的Lambda表达式:

				序号
			
				格式
		

				1
			
				[capture list] (params list) -> return type {function body}
		

				2
			
				[capture list] (params list) {function body}
		

				3
			
				[capture list] {function body}
		

	一些关于 lambda 表达式的细节

	1. 延迟调用

	按值捕获与按引用捕获的区别.

	 
int a = 0;
auto f = [=]{ return a; };      // 按值捕获外部变量
a += 1;                         // a被修改了
std::cout << f() << std::endl;  // 输出依旧为0,如果想要跟着被改变需要使用引用捕获

	 

	2. lambda 表达式转换成函数指针没有捕获变量的 lambda 表达式可以直接转换为函数指针, 而捕获变量的 lambda 表达式则不能转换为函数指针.

	 
typedef void(*Ptr)(int*);
Ptr p = [](int* p){delete p;};  // 正确, 没有状态的 lambda (没有捕获)的lambda表达式可以直接转换为函数指针
Ptr p1 = [&](int* p){delete p;};  // 错误, 有状态的 lambda 不能直接转换为函数指针

	 

	3. 嵌套

	 
int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5); //16

	 

	4. 作为 STL 算法函数谓词参数:

	 
std::vector myvec{ 3, 2, 5, 7, 3, 2 };
std::sort(myvec.begin(), myvec.end(), [](int a, int b) -> bool { return a < b; });

	 

	C++14 中的 lambda 新特性

	1. lambda 捕捉表达式/右值

	 
// 利用表达式捕获,可以更灵活地处理作用域内的变量
int x = 4;
auto y = [&r = x, x = x + 1] { r += 2; return x * x; }();
// 此时 x 更新为6,y 为25

// 直接用字面值初始化变量
auto z = [str = "string"]{ return str; }();
// 此时z是const char* 类型,存储字符串 string

//不能复制只能移动的对象,可以用std::move初始化变量
auto myPi = std::make_unique(3.1415);
auto circle_area = [pi = std::move(myPi)](double r) { return *pi * r * r; };
cout << circle_area(1.0) << endl; // 3.1415

	 

	2. 泛型 lambda 表达式:

	 
auto add = [](auto x, auto y) { return x + y; };//推断类型
int x = add(2, 3);   // 5
double y = add(2.5, 3.5);  // 6.0

	 

	函数适配器

	将函数对象与其它函数对象, 或者特定的值, 或者特定的函数相互组合的产物. 由于组合特性, 函数适配器可以满足特定的需求, 头文件  定义了几种函数适配器:

	std::bind(op, args...): 将函数对象 op 的参数绑定到特定的值 args.

	std::mem_fn(op): 将类的成员函数转化为一个函数对象.

	std::not1(op), std::not2(op),std::unary_negate,std::binary_negate: 一元取反器和二元取反器.

	std::bind

	这里的函数对象就包括了上面所有的类型, 当然也包含自己, 因此可以利用 std::bind 封装出很多有意思的功能.

	下面的例子来自于分享.

	• 嵌套

	 
// 定义一个接收一个参数,然后将参数加10再乘以2的函数对象
auto plus10times2 = std::bind(std::multiplies{},
        std::bind(std::plus{}, std::_1, 10), 2);
cout << plus10times2(4) << endl; // 输出:  28 

// 定义3次方函数对象
auto pow3 = std::bind(std::multiplies{},
        std::bind(std::multiplies{}, std::_1, std::_1),
        std::_1);
cout << pow3(3) << endl;  // 输出: 27

	 

	• 调用类中的成员函数

	 
class Person{
public:
    Person(const string& n) : name{ n } {}
    void print() const { cout << name << endl; }
    void print2(const string& prefix) { cout << prefix << name << endl; }
private:
    string name;
};
int main()
{
    vector p{ Person{"Tick"}, Person{"Trick"} };
    // 调用成员函数print
    std::for_each(p.begin(), p.end(), std::bind(&Person::print, std::_1));
    // 此处的std::_1表示要调用的Person对象,所以相当于调用arg1.print()
    // 输出: Tick   Trick
    std::for_each(p.begin(), p.end(), std::bind(&Person::print2, std::_1,
        "Person: "));
    // 此处的std::_1表示要调用的Person对象,所以相当于调用arg1.print2("Person: ")
    // 输出: Person: Tick   Person: Trick

    return 0;
}

	 

	• 调用 lambda 表达式

	 
vector data{ 1, 2, 3, 4 };
auto func = std::bind([](const vector& data) { cout << data.size() << endl; },
                        std::move(data));
func();  // 4
cout << data.size() << endl;  // 0

	 

	• 调用范围内函数

	 
char myToupper(char c){
    if (c >= 'a' && c <= 'z')
        return static_cast(c - 'a' + 'A');
    return c;
}

int main()
{
    string s{ "Internationalization" };
    string sub{ "Nation" };
    auto pos = std::search(s.begin(), s.end(), sub.begin(), sub.end(),
                        std::bind(std::equal_to{}, 
                            std::bind(myToupper, std::_1),
                            std::bind(myToupper, std::_2)));
    if (pos != s.end()){
        cout << sub << " is part of " << s << endl;
    }
    // 输出: Nation is part of Internationalization
    return 0;
}

	 

	• 默认 pass-by-value, 如果想要 pass-by-reference, 需要用 std::ref 和 std::cref 包装.

	std::cref 比 std::ref 增加 const 属性.

	 
void f(int& n1, int& n2, const int& n3){
    cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
    ++n1;
    ++n2;
    // ++n3;  //无法编译
}

int main()
{
    int n1 = 1, n2 = 2, n3 = 3;
    auto boundf = std::bind(f, n1, std::ref(n2), std::cref(n3));
    n1 = 10;
    n2 = 11;
    n3 = 12;
    cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
    boundf();
    cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '
';
    //  Before function : 10 11 12
    //  In function : 1 11 12
    //  After function : 10 12 12

    return 0;
}

	 

	std::mem_fn

	与 std::bind 相比, std::mem_fn 的范围又要小一些, 仅调用成员函数, 并且可以省略掉用于调用对象的占位符.

	因此使用 std::men_fn 不需要绑定参数, 可以更方便地调用成员函数.

	 
vector p{ Person{ "Tick" }, Person{ "Trick" } };
std::for_each(p.begin(), p.end(), std::mem_fn(&Person::print));
// 输出: Trick Trick
Person n{ "Bob" };
std::mem_fn(&Person::print2)(n, "Person: ");
// 输出: Person: Bob

	 

	std::mem_fn 还可以调用成员变量

	 
class Foo{
public:
    int data = 7;
    void display_greeting() { cout << "Hello, world.
"; }
    void display_number(int i) { cout << "number: " << i << '
'; }
    
};
int main()
{
    Foo f;
    // 调用成员函数
    std::mem_fn(&Foo::display_greeting)(f);  // Hello, world.
    std::mem_fn(&Foo::display_number)(f, 20);  // number: 20
    // 调用数据成员
    cout << std::mem_fn(&Foo::data)(f) << endl;  // 7
    return 0;
}

	 

	std::not1 、std::not2、std::unary_negate、std::binary_negate

	std::not1, std::not2 分别构造一个与谓词结果相反的一元/二元函数对象.

	std::unary_negate, std::binary_negate 分别返回其所保有的一元/二元谓词的逻辑补的包装函数对象, 其对象一般为 std::not1, std::not2 构造的函数对象,即又加了一层包装.

	下面分别是其使用示例:

	 
//std::not1
#include 
#include 
#include 
int main(int argc, char **argv) 
{  
    std::vector nums = {5, 3, 4, 9, 1, 7, 6, 2, 8};
    std::function less_than_5 = [](int x){ return x <= 5; };
    // count numbers of integer that not less and equal than 5
    std::cout << std::count_if(nums.begin(), nums.end(), std::not1(less_than_5)) << "
";
    //输出结果4
    return 0;
}

//std::not2
using namespace std;
int main(int argc, char **argv) 
{  
    std::vector nums = {5, 3, 4, 9, 1, 7, 6, 2, 8};
    std::function ascendingOrder = [](int a, int b) { return a
#include 
#include 
#include 
struct less_than_7 : std::unary_function{
    bool operator()(int i) const { return i < 7; }
};
 
int main()
{
    std::vector v;
    for (int i = 0; i < 10; ++i) v.push_back(i);
    std::unary_negate not_less_than_7((less_than_7()));
    std::cout << std::count_if(v.begin(), v.end(), not_less_than_7);
    //输出8 9

}

//std::binary_negate
struct same : std::binary_function{
    bool operator()(int a, int b) const { return a == b; }
};
 
int main()
{
    std::vector v1;
    std::vector v2;
    for (int i = 0; i < 10; ++i) v1.push_back(i);
    for (int i = 0; i < 10; ++i) v2.push_back(10 - i);
    std::vector v3(v1.size());
    std::binary_negate not_same((same()));
    std::transform(v1.begin(), v1.end(), v2.begin(), v3.begin(), not_same);
 
    std::cout.setf(std::boolalpha);
    for (int i = 0; i < 10; ++i)
        std::cout << v1[i] << ' ' << v2[i] << ' ' << v3[i] << ' ';
//输出:0 10 true 1 9 true 2 8 true 3 7 true 4 6 true 5 5 false 6 4 true 7 3 true 8 2 true 9 1 true
}

	 

	std::not_fn

	注意 C++17 已经把上面的 std::not1, std::not2, std::unary_negate 和 std::binary_negate 抛弃, 统一由 std::not_fn 替代.

	 
//移除把满足谓词p的元素都copy到容器中
template 
auto FilterRemoveCopyIf(const std::vector& vec, Pred p) {
    std::vector out;
    std::remove_copy_if(begin(vec), end(vec), 
                        std::back_inserter(out), std::not_fn(p));
    return out;
}

	 

	std::function

	五花八门的 Callable, 个个都是人才, 但是不好带(不好实现 generic programming), 所以一个把所有 callable 对象封装成统一形式的类型模板.

	std::function 的实例可以对任何可以调用的目标实体进行存储, 复制, 和调用操作, 实现一种类型安全的包裹.

	基础介绍

	原型为:

	 
template< class R, class... Args > //R是返回值类型,Args是函数的参数类型
class function;

	 

	其存储的可调用对象被称为 std::function 的目标. 若 std::function 不含目标, 则称它为空. 调用空 std::function 的目标导致抛出 std::bad_function_call 异常.

	std::function 满足可复制构造 (Copy Constructible) 和可复制赋值 (Copy Assignable) (参考).

	瑞士军刀一般的功能, 代码例子如下:

	 
#include 
#include 
 
struct Foo {
    Foo(int num) : num_(num) {}
    void print_add(int i) const { std::cout << num_+i << '
'; }
    int num_;
};
 
void print_num(int i){
    std::cout << i << '
';
}
 
struct PrintNum {
    void operator()(int i) const
    {
        std::cout << i << '
';
    }
};
 
int main()
{
    // 存储自由函数
    std::function f_display = print_num;
    f_display(-9);
 
    // 存储 lambda
    std::function f_display_42 = []() { print_num(42); };
    f_display_42();
 
    // 存储到 std::bind 调用的结果
    std::function f_display_31337 = std::bind(print_num, 31337);
    f_display_31337();
 
    // 存储到成员函数的调用
    std::function f_add_display = &Foo::print_add;
    const Foo foo(314159);
    f_add_display(foo, 1);
    f_add_display(314159, 1);
 
    // 存储到数据成员访问器的调用
    std::function f_num = &Foo::num_;
    std::cout << "num_: " << f_num(foo) << '
';
 
    // 存储到成员函数及对象的调用
    using std::_1;
    std::function f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
    f_add_display2(2);
 
    // 存储到成员函数和对象指针的调用
    std::function f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
    f_add_display3(3);
 
    // 存储到函数对象的调用
    std::function f_display_obj = PrintNum();
    f_display_obj(18);
 
    auto factorial = [](int n) {
        // 存储 lambda 对象以vwin
"递归 lambda ",注意额外开销
        std::function fac = [&](int n){ return (n < 2) ? 1 : n*fac(n-1); };
        // note that "auto fac = [&](int n){...};" does not work in recursive calls
        return fac(n);
    };
    for (int i{5}; i != 8; ++i) { std::cout << i << "! = " << factorial(i) << ";  "; }
}


	 

	可能的输出

	 
-9
42
31337
314160
314160
num_: 314159
314161
314162
18
5! = 120;  6! = 720;  7! = 5040;

	 

	回调函数

	std::function 的应用之一: 结合 typedef 定义函数类型构造回调函数.

	 
typedef std::function CallBack;
Class MessageProcessor {
private:
    CallBack callback_;
public:
    MessageProcessor(Callback callback):callback_(callback){}
    void ProcessMessage(const std::string& msg) {
        callback_(msg);
    }
};

	 

	　　审核编辑：汤梓红

捕获形式	说明
[]	不捕获任何外部变量
[变量名, …]	默认以值得形式捕获指定的多个外部变量(用逗号分隔), 如果引用捕获, 需要显示声明(使用 & 说明符)
[this]	以值的形式捕获 this 指针
[=]	以值的形式捕获所有外部变量
[&]	以引用形式捕获所有外部变量
[=, &x]	变量x以引用形式捕获,其余变量以传值形式捕获
[&, x]	变量x以值的形式捕获,其余变量以引用形式捕获

序号	格式
1	[capture list] (params list) -> return type {function body}
2	[capture list] (params list) {function body}
3	[capture list] {function body}

阅读全文

函数(61194) 函数(61194)
指针(70354) 指针(70354)
C++(72840) C++(72840)
标准库(7341) 标准库(7341)

关于C++模板总结

大家好，今天给大家分享一篇关于 C++ 模板总结概述。

2022-09-19 11:55:21

364

汇编语言模块调用C++函数实例

现在编写一个简单的应用程序，提示用户输入整数，通过移位的方式将其与 2 的幕 (2¹〜2ⁿ) 相乘，并用填充前导空格的形式再次显示每个乘积。输入-输出使用 C++。汇编模块将调用 3 个 C++ 编写的函数。程序将由 C++ 模块启动。

2022-10-11 09:52:20

672

C++打印类型名称的分析与实现

打印类型名称，听起来像是一个很简单的需求，但在目前的C++当中，并非易事。

2022-10-20 14:08:11

1050

C++中的四种类型转换分别是哪些？C++中析构函数的作用是什么

C++中的四种类型转换分别是哪些？C++中析构函数的作用是什么？在C语言中关键字static主要有何作用？

2021-12-24 06:57:40

C++笔记004：C++类通俗点说—— C结构体复习

` 本帖最后由 tyyhmtyyhm 于 2018-5-12 09:37 编辑 C++类通俗点说—— C结构体复习核心：C++的类就是对C语言的结构体进行了扩展，C++的结构体可以包含函数

2018-03-05 12:53:38

C++编写的DLL 函数里面有参数类型char*，请问用labview调用应该对应什么类型？

C++编写的DLL 函数里面有参数类型char*，请问用labview调用应该对应什么类型？

2015-11-16 17:31:11

C++能用来做什么？

应用。5、科学计算：C++有先进的数值计算库、泛型编程6、操作系统：操作系统主要使用的编程语言是C，但是C++凭借其对C的兼容性，面向对象性质也开始在该领域有一席之地。对于C++的总结：总而言之，把c

2019-08-13 08:00:00

C++软件工程师面试题

1、 c++是面向对象的编程语言吗?C++中虚函数(virtual) 是什么？有什么好处？（1）C++不是纯面向对象的语言，C++是面向对象和过程的，因为C++支持类和过程。（2）虚函数

2011-03-01 16:23:53

C/C++与汇编混合编程有什么好处？

项目中，通过ATPCS规定与C程序相互调用及访问。2. 内嵌汇编语言指令用C/C++程序嵌入汇编程序中可以实现一些高级语言没有的功能，提高程序执行效率。armcc编译器的内嵌汇编器支持ARM指令集

2017-09-23 20:48:46

C/C++中调用Java不同类中的静态方法有哪些

C/C++中调用Java不同类中的静态方法有哪些？C/C++调用java的方法是什么？

2021-09-30 08:12:09

C/C++中的整型常识

C/C++中的整型常识很多人对C/C++中的整型不太了解，导致代码移植的时候出现问题，本人在此总结一下，若有描述错误，请务必指出，谢谢！     a. C/C++

2008-10-07 11:12:41

C/C++回调函数

C/C++回调函数首先看一下回调函数的官方解释：回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数

2023-02-11 15:25:13

C和C++中const的用法比较

为0)。针对C中const的上述局限性，C++作出了重大的改进。在C++中，可以使用const来定义常数，因为const在编译器的控制范畴内，而非由预处理器控制，所以可以进行类型安全检查，也方便进行作用

2016-11-11 10:00:26

C和C++的区别，有你不知道的

; //定义了两个结构体变量，默认情况下为public类型。C++：类class Student{ private：int num;char name[20];char sex;public:void display(){ cout

2019-05-07 15:57:06

C语言到C++的转变并不难！看完就懂了

` 本帖最后由 Hx_hxhx 于 2019-8-12 15:56 编辑 c语言和c++是两种完全不同的编程思想，分别是面对过程和面向对象。个人建议，把c学通了之后，去学精c++，毕竟性能上其实

2019-08-12 15:54:51

c++中调用labview中创建的dll文件

小弟用labview编了一个程序做成dll后想用c++调用，但是始终没发成功，有没有哪位大神赐教啊？不胜感激，最好能有每一步的截图，最好是能用vs2008的，谢谢

2013-11-05 16:00:59

c++算法库的移植问题

目前有一个算法库用的c++ 用ccs在dsp上可以调试现在希望把库放在8168的dsp上需要将c++转换成c 有个工具 mmCC C++-to-C Translator、不知道论坛里有没有或者大家谁有如果找不到mmcc 那么 8168上dsp用c调用c++库有没有可行性

2018-06-21 13:14:22

可调用的VEE服务器，Matlab无法识别

] Callable VEE ServerHello VRF，我试图使用可调用的VEE服务器（使用VEE Rev 7.51）和Matlab（版本7）作为ActiveX客户端。我可以实例化服务器，加载库（vee

2019-09-06 13:33:07

调用C++写的DLL文件时，提示”无法启动程式，因为计算机丢失api-ms-crt-runtime“时，需要安装C++的运行库，如附件

附件是C++运行库，当调用C++的DLL时，需要安装

2016-11-26 16:02:35

Android NDK编程--- C/C++调用Java不同类中的静态方法

前言上一篇我们介绍了《Android NDK编程（四）--- C/C++调用Java中的方法》，主要是C/C++中调用Java的方法，这一篇我们针对上一篇的内容再延伸说一下，关于调不同类...

2021-07-02 07:56:52

JAVA和C++区别

不支持多重继承，但允许一个类继承多个接口(extends+implement)，实现了c++多重继承的功能，又避免了c++中的多重继承实现方式带来的诸多不便。 3．数据类型及类 Java是完全面向对象

2016-04-11 15:19:26

JAVA和C++区别

2016-10-10 14:50:32

Java和C++的区别

2018-09-13 16:02:06

Labview调用外部DLL时候，输入和输出参数的数据类型，以及函数返回值的数据类型。

。***************************************************************************在C++源代码里面。typedef void * HLD3_HANDLE; // デバイスハンドルtypedef DWORD far*LPDWORD;//指向WORD类型的指针

2017-05-26 13:29:22

Linux C/C++ 学习路线相关资料下载

一、秋招 Linux C/C++ offer 情况二、Linux C/C++ 方向的一些思考三、计算机基础知识的梳理四、C++ 方向的深入学习路线五、项目 + 亮点 + 面试的一些思考六、总结前言

2021-11-11 06:36:51

STM32c/c++混合编程

extern"C"包起来extern “C”{}还不行，要把写c++代码的.c文件的类型改为.c++ sourse type...

2021-08-23 07:47:12

labview调用c++中的取地址符对应labview什么数据类型？

调用c++动态链接库，有一个参数是地址类&data，labview对应什么数据类型？急急急！！！！！！！！！！求大神帮忙

2016-08-18 11:47:21

labview能不能调用c++编写的且含有类的dll

如题，用c++写的程序，里面有不少的类，封装成dll后，能用labview的CLN调用吗

2015-04-14 15:32:11

python用pyserial读取串口错误类型及解决办法

is not callable没有返回值正确代码：ser = serial.Serial('COM7', 115200, 8, 'N', 1)flag = ser.is_open原因：调用属性is_open时将其视为函数，写成 ser.is_open()。关于is_open的功能及用法，可参见python库

2022-01-13 07:12:44

《C/ C++/ Java 程序设计经典教程》

本帖最后由圈圈7029 于 2014-11-13 11:41 编辑《C/ C++/ Java 程序设计经典教程》（Deitel 著）●集作者几十年程序设计经验之精华，从软件工程

2014-11-13 11:22:36

介绍MATLAB与C++的几种接口方式

mxArray *prhs[] )其名称和参数类型不许有任何改变，在mexFunciton函数中可以调用你刚定义好的C++程序。3、MEX文件的编译MATLAB提供了专门编译MEX文件的工具：mex，它可以把你

2011-11-18 22:45:41

使用C++项目的正确方法是什么？

`main.cpp`；* 将 C++ 头文件包含到 `main.cpp` 中并创建 C++ 类的实例，从 `main()` 函数中调用它们的成员函数；* 每当重新生成代码（和更新 `main.c`）时，将更新复制到 `main.cpp`。我希望有比这更好的方法。请指教。

2023-02-07 08:34:56

关于C++中函数指针的使用

关于C++中函数指针的使用(包含对typedef用法的讨论) （一）简单的函数指针的应用。 //形式1：返回类型(*函数名)(参数表) char (*pFun)(int); char

2018-07-13 03:51:04

关于C++中的函数重载机制

,而且同类型的同名函数能够更好地发挥多种功能.宏观体现就是使用一个函数名字可以完成各种同类型但是不同细节的函数调用(例如,参数的类型不同,或者仅仅是多了一个控制量参数......).所以C++中的函数

2016-10-01 17:18:42

关于C++的知识点总结的太棒了

关于C++的知识点总结的太棒了

2021-10-11 08:12:32

在ubuntu中用vscode编译调试C\C++

3. 基于跨平台多类型代码编辑器VScode关于在ubuntu中用vscode编译调试C\C++Ubuntu安装vscode图形安装，首先在虚拟机应用商店找到vscode2.点击“安装”进行安装3.安装成功关于在ubuntu中用vscode编译调试C\C++安装vscode的C\C++插件...

2021-12-22 08:01:01

如何使用DevEco Studio创建Native C++应用

C++”模板，实现了通过Node-API调用C标准库的功能。本示例通过调用C标准库接口来演示调用过程，具体接口是C标准库的计算两个给定数和，并将结果返回到页面展示。通过这个应用我们可以掌握

2023-02-22 14:24:20

如何在C++中包含C代码？

我有一个问题，我不能在 C++ 中包含 C 代码，反之亦然。不同的站点建议通过在 C++ (Model.hpp) 的头文件中包含 C 的头文件来解决这个问题，例如：#ifdef

2023-01-11 06:42:26

如何在MDK中使用C++，整理的经验

;C"{3.#endif4.5.6.。。。。。。。。。。。。。这里写c语言代码7.8.9.#ifdef __cplusplus10. }11. #endif这样在使用C++调用时就使用C++编译器编译

2016-03-10 15:32:56

如何在ubuntu中用vscode编译调试C\C++

这里写目录标题可视化的代码跟踪调试1.VScode的安装2.在ubuntu中用vscode编译调试C\C++3.总结可视化的代码跟踪调试1.VScode的安装1.我们首先在应用商店里面找到

2021-12-14 07:11:30

如何学习C++，如何学好C++

最近，很多学员都给我发邮件问我应该如何学习C++，如何学好C++？那么作为一个从C语言小白摸爬滚打、入坑无数到成长为如今的高级C++游戏开发工程师、高级C++服务端工程师、项目经理、技术总监、我想跟

2021-08-20 06:27:53

如何学习编程c++语言？

　　如何学习编程c++语言？粤嵌来讲解嵌入式C语言在各种项目中要用到的知识点，尤其是嵌入式C语言之变量与常量的内容：　　1、变量类型和表示方法　　如何学习编程c++语言？什么是变量?一句话，变量是存储数据的空间。由于数据的类型有多种，有整数、小数(浮点数)和字符等等，那么对应的变量就有整型...

2021-12-15 08:28:41

如何把C++的源程序改写成C语言

;}六．重载类中重载有函数重载和运算符重载两种：1）函数的重载函数重载满足的条件是：函数名相同，参数个数或者参数类型不同。这样在调用的时候，会根据你输入的参数不同，调用不同的函数。在C中只好分别

2021-06-30 10:54:41

如何把C++的源程序改写成C语言

的重载函数重载满足的条件是：函数名相同，参数个数或者参数类型不同。这样在调用的时候，会根据你输入的参数不同，调用不同的函数。在C中只好分别起不同的名字，没有别的解决办法。2）运算符重载运算符重载只是

2020-07-08 20:51:50

如何把C++的源程序改写成C语言

重载有函数重载和运算符重载两种：1）函数的重载函数重载满足的条件是：函数名相同，参数个数或者参数类型不同。这样在调用的时候，会根据你输入的参数不同，调用不同的函数。在C中只好分别起不同的名字，没有

2020-07-11 09:34:24

如何把C++的源程序改写成C语言

2021-11-17 10:16:27

如何把C++的源程序改写成C语言

）函数的重载函数重载满足的条件是：函数名相同，参数个数或者参数类型不同。这样在调用的时候，会根据你输入的参数不同，调用不同的函数。在C中只好分别起不同的名字，没有别的解决办法。2）运算符重载运算符重载只是

2021-07-05 14:59:39

如何把C++的源程序改写成C语言

，少走弯路！七．其他以上就是C＋＋中主要的与C的区别最大而且最常用的特性及修改方法。其他的还有一些比如模板的使用等等，这些都是为了方便编程，复用代码。C中没有，只好自己写多个函数来分别实现。另外还有参数列表里的&符号要用指针替代，缺省值也要去掉，而在调用的时候要注意将缺省值写上。`

2021-07-07 09:31:16

如何用C编写DLL文件供labview调用？

最近在学习labview调用DLL文件的方法，目前已经知道如何使用VI生成DLL文件供labview调用，现在想学习使用C语言或是C++编程形成DLL文件，以实现labview调用。寻求C语言编写

2015-09-07 11:09:49

学习C++的方法以及C++的就业方向

学习方向：嵌入式+人工智能嵌入式是一门技术学习目标1.嵌入式开发概述；（面向对象在嵌入式开发中角色）2.嵌入式Linux C++编程；（C++概述、C++学习方法、C++开发工具）3.C到C++升级

2021-12-24 07:32:38

嵌入式-C++函数的重载

一、什么是函数的重载两个以上的函数，具有相同的函数名，通过参数的类型和参数的个数不同。编译器自行匹配，自动确定调用哪一个函数二、函数重载的作用 C++允许功能相近的函数在相同的作用域内以相同

2023-06-28 13:54:31

怎么从VEE内调用可调用的VEE服务器功能

我正在尝试使用VEE创建一个Callable VEE客户端，当涉及获取CallServer句柄，加载另一个VEE库，获取加载库中的用户函数列表甚至获取名称，类型和每个函数所需的参数数量。在我遇到

2019-04-12 16:04:26

怎么将信号输入VSA？

/ c ++代码将数据泵入S-function，通常在Agilent Simulink驱动程序下面]。请注意，我想避免Simulink并将信号直接输入到安捷伦S-function下的/ c ++可调用

2019-07-04 06:51:10

我在进行C++中调用NI-DAQmx C API函数时，出现错误，请高手指教

在进行C++中调用NI-DAQmx C API函数时，出现错误，请高手指教。我编译的时候是正确的，但是运行以后出现如附件的错误，请帮个忙，指点一下！谢谢

2011-12-14 13:14:44

金橙子打标卡labview打标开发没头绪？c#封装成dll后labview调用真香！

激光打标卡大品牌金橙子广泛用于工业打标领域，其自带c#和c++例程，但是没有labview例程，由于c++和c#都涉及到指针和窗口句柄，而且c++仅字符就有很多种不同类型，想要直接用labview

2020-07-26 01:18:11

阿里云SDK再升级，宣布支持C++语言

让C++ 语言开发者更加便捷地使用SDK调用产品API来操作产品，包括二次开发、自动化运维的实现等。点此查看原文：http://click.aliyun.com/m/41955/日前，阿里云官方SDK

2018-02-08 13:48:34

鸿蒙DevEco如何调用c++的API接口？

建立jni之后，调用c++的API接口（包含在华为手机上重新实现编译生成的so文件和.h头文件），请问如何？我过去的方法，但是没有成功：尝试失败一：将编译好的test.so文件和test.h文件修改

2022-04-24 10:54:40

C++教程第三章数据类型

C++教程第三章数据类型什么是数据类型一定的数据在计算机的内部表示；该数据所表示的值的集合；在该数据上的一系列操作。

2010-05-15 17:56:59

C++教程之函数的递归调用

C++教程之函数的递归调用在执行函数 f 的过程中，又要调用 f 函数本身，称为函数的递归调用；形式上：一个正在执行的函数调用了自身；这种递归称之

2010-05-15 18:00:38

CodeViz--一款分析C/C++源代码中函数调用关系的调用

程序开发中，有时候需要阅读别人的代码，这时理解代码的组织结构就显得非常重要。CodeViz是一款分析C／C＋＋函数调用关系的调用图生成工具，非常有助于代码的阅读和理解，该项目

2011-04-04 20:50:49

C++小白自学基础教程之copy构造函数调用时机09

C++

电子学习发布于 2023-01-12 21:12:38

C++小白自学基础教程之copy构造函数的调用时机07

C++

电子学习发布于 2023-01-12 21:13:13

C++小白自学基础教程之c++类型类型检查加强12

C++

电子学习发布于 2023-01-12 21:19:47

C++小白自学基础教程之构造和析构调用顺序21

C++

电子学习发布于 2023-01-12 21:23:05

C++小白自学基础教程之构造函数的调用规则研究15

C++

电子学习发布于 2023-01-12 21:32:24

C++小白自学基础教程之调用的时才会执行06

C++

电子学习发布于 2023-01-12 21:44:33

C++小白自学基础教程之新增数据类型bool类型13

C++

电子学习发布于 2023-01-12 22:24:42

C++零基础教程之reinterpret_cast类型转换，轻松上手C++类型转换

编程语言C++语言

电子学习发布于 2023-01-14 11:44:45

C++面向对象关于MFC的一些简单应用和总结

C++面向对象关于MFC的一些简单应用和总结.

2015-11-09 17:15:36

ARM汇编 C语言 C++ 相互调用

如果对于C++库中含有类的，可以在二次接口函数中生成临时对象来调用对应的功能函数，当然要根据实际情况来定了。

2017-01-19 14:06:51

1251

浅谈C、C++ 和 ARM 汇编语言之间的调用

之间的调用本节提供一些示例，显示如何从C++调用C和汇编语言代码，以及从C和汇编语言调用 C++ 代码。其中包括调用约定和数据类型。主要包括下面内容：相互调用的一般规则； C++语言的特定信息

2017-10-19 09:24:28

面部检测C-callable RTL IP的演示

Xylon在Embedded World 2015上使用MicroZed套件演示了面部检测C可调用RTL IP

2018-11-27 06:06:00

1654

C++的一些试题资料总结免费下载

本文档的主要内容详细介绍的是C++的一些试题资料总结免费下载。

2019-01-29 10:04:27

C++容器的使用代码资料总结免费下载

本文档的主要内容详细介绍的是C++容器的使用代码资料总结免费下载。

2019-01-29 10:52:00

如何在中断C函数中调用C++

之前，我们在单片机程序开发时都会面对中断函数。众所周知的，这个中断函数肯定是要用C函数来定义的。我在用C++进行程序开发的时候就发现了一个需要解决了问题：在断函数中怎么调用C++的成员函数？

2019-05-09 18:17:00

SIM卡的类型和尺寸，这篇文章总结全了！

2019-07-02 11:40:48

31019

Callable接口介绍 Runnable和Callable的区别

Callable,新启线程的一种方式,返回结果并且可能抛出异常的任务,在前面的新启线程的文章中用过,但是没有具体讲解

2020-10-16 11:30:59

2607

C++中类的继承访问级别学习总结（二）

上一篇文章我们介绍了c＋＋中类的继承学习总结；今天我们继续来分享c＋＋中类的继承中的访问级别的学习总结。一、继承中的访问级别学习：1、子类是否可以直接访问父类的私用成员吗？从面向对象理论角度来看：子类拥有父类的一切属性和行为，也就是说，子类能够直接访问父类的私有成员

2020-12-24 16:10:47

491

C++之重载函数学习总结

函数重载是c＋＋对c的一个重要升级；函数重载通过参数列表区分不同的同名函数；extern关键字能够实现c和c＋＋的相互调用；编译方式决定符号表中的函数名的最终目标名

2020-12-24 17:10:57

595

c++ 之布尔类型和引用的学习总结

在c语言里面我们知道是没有布尔数据类型的，而在C＋＋中添加了布尔数据类型（bool），它的取值是：true或者false（也就是1或者0），在内存大小上它占用一个字节大小。

2020-12-24 18:03:54

391

C语言与C++相互调用

1C与C++相互调用在一个嵌入式系统中大部分的底层和驱动层更多的是采用C语言来进行开发，而上层应用、服务更多的采用C++等高级语言来进行面向对象等方面的开发方式，那么就存在一个上层调用底层

2021-01-18 11:05:06

2835

EE-128：C++中的DSP：从C++调用汇编类成员函数

EE-128：C++中的DSP：从C++调用汇编类成员函数

2021-04-16 17:04:21

C语言与C++面试知识点总结

相对而言，C语言和C++相关的面试题比较少见，没有Java方向写的人那么多，这是一篇 C 语言与 C++面试知识点总结的文章，个人感觉非常难得，希望能对大家有所帮助。

2022-05-12 14:59:52

1191

C语言与C++面试知识点总结

2022-05-13 11:59:39

1588

虚函数，C++开发者如何有效利用

。我们将在下文更为详细地讨论运行时多态。不论函数调用所使用的指针或引用类型如何，虚函数最为重要的工作是确保函数调用正确。

2023-02-11 09:39:26

628

现代C++之模板类型推导

传统C++中，参数的类型都必须明确定义，这其实对我们快速进行编码没有任何帮助，尤其是当我们面对一大堆复杂的模板类型时，必须明确的指出变量的类型才能进行后续的编码，这不仅拖慢我们的开发效率，也让代码变得又臭又长

2023-03-02 16:18:37

503

C++学习笔记之c++的基本认识

自这篇文章我们即将开始C++的奇幻之旅，其内容主要是读C++ Primer的总结和笔记，有兴趣可以找原版书看看，对于学习C++还是有很大帮助的。这篇文章将从一个经典的程序开始介绍C++的类型、变量、表达式、语句、控制流和函数的相关内容，由此可以建立起对于C++总体上的认识

2023-03-17 13:57:16

493