1回答
static inline**，** extern inline 和普通的 inline 函数有什么区别？
我见过一些关于这件事的模糊解释。据我所知，static inline不仅仅是一个inline函数，它只在某个文件中引用，static关键字通常意味着这一点。extern inline也是如此--我猜，这与extern变量的解释不同。任何答案都将不胜感激！
浏览 5提问于2014-07-28得票数 41
回答已采纳
例如，我在golang进行了以下测试：
// inline-tests.go
package inlinetests
func plus(a, b int) int {
return a + b
}
func plus_plus(a, b, c int) int {
return plus(plus(a, b), plus(b, c))
}
func plus_iter(l ...int) (res int) {
for _, v := range l {
res += v
}
return
}
如果我试图构建它，我会收到以下信息：
浏览 3提问于2017-08-23得票数 13
回答已采纳
考虑一下
template<typename T>
inline void f(T) {} // "inline" can be safely removed.
和
inline void f(auto) {} // Can "inline" also be safely removed?
根据C++标准，在后一种情况下， inline 可以安全地删除吗？。
浏览 3提问于2020-04-12得票数 3
回答已采纳
2回答
内联还有用吗？
、、、、
我相信，inline是过时的，因为我读了
无论如何将函数指定为inline，编译器都可以忽略它的请求:编译器可能会内联地展开一些、全部或没有调用指定为inline的函数的位置。
然而，似乎理解了一些我不理解的东西。在中，他和我反复讨论inline是否仍然有用。
这个问题不是关于：
inline的历史使用或者inline仍然可以用来提示编译器到inline函数：。
内联函数代码的优缺点：
强制编译器使用inline函数代码：
请记住编译器可以随意使用inline，因此inline在那里没有帮助：可以用来强制， 不建议修改编译后的代码？<code>E 236
浏览 7提问于2015-04-22得票数 90
回答已采纳
1回答
我很难理解为什么编译器和平台之间的行为会有如此大的差异。
这里是一个扩展的 of 。
CMakeLists.txt：
cmake_minimum_required(VERSION 3.7.2)
project(static_inline)
set(CMAKE_CXX_STANDARD 14)
add_library(lib SHARED collect.h collect.cpp)
target_compile_definitions(lib PRIVATE BUILD_DLL)
add_executable(static_inline main.cpp)
target_link_lib
浏览 1提问于2021-06-24得票数 1
常量表达式函数是一个常量表达式。在初始化静态值期间，内联函数是否被视为常量表达式？
constexpr int constexpr_add_one(int x) { return x + 1; } // implies inline
inline int inline_add_one(int x) { return x + 1; }
static const int constexpr_value = constexpr_add_one(0xaaaa0000);
static const int inline_value = inline_add_one(0xbbbb0000);
// A
浏览 1提问于2016-06-11得票数 1
4回答
我遇到了一个头文件，其中包含各种函数原型声明，这些声明是内联的和const的：
inline bool Foo1() const;
inline bool Foo2() const;
inline bool Foo3() const;
...
我知道内联关键字允许编译器在调用函数时(可能)展开函数，但是为什么不包括函数的主体呢？
如果定义包含在头文件中，对我来说就更有意义了：
inline bool Foo1() const { return m_Foo1; };
inline bool Foo2() const { return m_Foo2; };
inline bool Foo3() c
浏览 8提问于2013-04-10得票数 4
回答已采纳
关于在上使用inline指令，有一个很好的解释
有人能给我解释一下在头文件上使用inline和__always_inline有什么区别吗？
还有，什么时候我更喜欢__always_inline而不是inline，或者相反？
浏览 5提问于2014-01-08得票数 8
让我们想象一下，一个blh.h头文件包含：
// A declaration without any code. We force inline
__attribute__((always_inline)) void inline_func();
以及包含以下内容的blah.cpp源文件：
#include "blah.h"
// The code of the inline function
void inline_func() {
...
}
// Use the inline function
void foo() {
inline_func();
}
浏览 9提问于2015-07-01得票数 1
回答已采纳
假设我们不暗示编译器在适用的情况下内联成员函数。
class Base
{
public:
inline virtual f() = 0;
};
class Derived : public Base
{
public:
virtual f() override; // no inline specifier here
};
我是否需要在inline中指定Derived::f()，还是可以省略关键字并确保virtual Derived::f()与inline Derived::f()相同？
我的意思是，inline关键字是为Derived::f()隐式指定的，还是
浏览 0提问于2019-03-27得票数 2
回答已采纳
1回答
我的头看起来是这样的：
#include "compiler.h"
INLINE FUNC(boolean, DIAG_APPL_CODE) Cdd_IsXcpActive(void){
return (boolean)(Cdd_Dcm_NvM_Coding_Adaption_Block[CODING_ADAPTION_XCP_ACTIVATION_OFFSET] == 1);
}
在编译器中。h
#define INLINE inline
#define FUNC(x, y) x
typedef unsigned char boolean;
被定义
当我试图编译时，我
浏览 2提问于2014-08-29得票数 1
回答已采纳
3回答
最小代码：
// --------inline.h--------
struct X {
static inline void foo ();
};
#ifdef YES
inline void X::foo () { cout << "YES\n"; }
#else
inline void X::foo () { cout << "NO\n"; }
#endif
// --------file1.cpp--------
#define YES // <----
#include"inline.h
浏览 2提问于2012-06-26得票数 9
回答已采纳
3回答
内部功能
、、
如果我这样做了：
void foo() {
if( .. ) {
inline int baa(..) { return .. }
} else {
inline int baa(..) { return .. }
}
}
然后调用：baa(..)在foo函数中，我得到implicit declaration of 'baa'。但是如果我做了原型声明：inline int baa(int);，错误是inline function 'baa' declared but never defined。我用内联函数来代替
浏览 4提问于2012-06-14得票数 0
回答已采纳
3回答
我应该把inline正确地放在哪里？
考验1.h：
class test1
{
inline void method1() {}
};
测试2.h：
class test2
{
void method2();
};
inline void test2::method2() {}
考验3.h：
class test3
{
inline void method3();
};
inline void test3::method3() {}
考验4.h：
class test4
{
inline void method4();
};
test4.cpp：
v
浏览 4提问于2014-01-31得票数 5
回答已采纳
我自己不使用IAR，我自己也不能测试它(否则我不会在这里问这个问题)。
我的问题是:在函数原型上应用#pragma inline=xxxxx (因为在gcc中使用__attribute__是可能的)，并且在文件中没有这个#pragma的某个地方有定义是否就足够了？
gcc的例子：
static inline int __attribute__((always_inline)) foo(int x);
/* .... */
static inline int foo(int x)
{
return x + x;
}
我希望在使用IAR编译器编译时也使用#pragma inline=.
浏览 3提问于2021-06-07得票数 1
5回答
我在foo.h头文件中定义了以下类
class Foo {
public:
inline int Method();
};
inline int Foo::Method() { // Implementation }
现在，我想将实现移到foo.cpp文件中。为此，我必须删除inline关键字，并将该方法的实现移动到如下所示的foo.cpp文件中
#include `foo.h`
inline int Foo::Method() { // Implementation }
我有两个问题：
我关于删除inline关键字的声明正确吗？一定要移除吗？
inline关键字的删除
浏览 4提问于2013-06-11得票数 3
回答已采纳
我审查了关于nullptr的一些守则，发现：
const
class nullptr_t
{
public:
template<class T>
inline operator T*() const
{ return 0; }
template<class C, class T>
inline operator T C::*() const
{ return 0; }
private:
void operator&() const;
} nullptr = {};
inline oper
浏览 1提问于2017-04-16得票数 3
回答已采纳
2回答
那么，这是一个错误还是故意的(使用VS2017更新15.3.4)？
以下内容不编译，因为CustomType是一个非文字的。
class A
{
public:
// ... some constructors
inline constexpr auto Value() const { return _value; }
private:
const CustomType _value;
}
但这完全没问题：
template< //... some templates
>
class A
{
public:
// ... some const
浏览 4提问于2017-09-14得票数 0
回答已采纳
这里在成功编译的定义和声明中都使用了inline：
#include <stdio.h>
inline int add(int a , int b);
inline int add(int a , int b){
return a+b;
}
int main(){
printf("%d\n", add(1,2));
return 0;
}
如果我们在定义或声明中使用inline，它也可以很好地编译。
哪种方法是正确的？在C中有没有一个规则来解释它，因为static和extern也有类似的规则
浏览 0提问于2020-06-15得票数 1
5回答
在函数前使用inline关键字和只在头文件中声明整个函数有什么区别？
所以..。
int whatever() { return 4; }
vs
.h：
inline int whatever();
.cpp：
inline int myClass::whatever()
{
return 4;
}
就此而言，这是做什么的：
inline int whatever() { return 4; }
浏览 0提问于2012-04-11得票数 26
我在尝试一些kotlin ->的基础知识。
程序：
fun createDate(day: Int, month: Int, year: Int, hour: Int = 0, minute: Int = 0, second: Int = 0) {
print("TEST", "$day-$month-$year $hour:$minute:$second")
}
createDate(1,7,1997)
错误：
error: none of the following functions can be called with the arguments
浏览 3提问于2018-09-04得票数 2
1回答
Javascript，ES6.我有三个文件：
inline-functions.js
\*
Bunch of small functions.
*/
some-module.js
import './inline-functions.js'
// uses many inline functions
main.js
import './inline-functions.js'
import './some-module.js'
// uses inline functions as well as classes from some-
浏览 1提问于2020-01-17得票数 1
回答已采纳
2回答
最近，我开始学习C++，这是我的第一个C++程序，但是它不起作用。
错误消息：
没有用于初始化“文档”的匹配构造函数。
我使用的IDE是Xcode。
class Document {
private:
int doc_id;
int lan_id;
std::vector<int>::size_type n_total;
std::vector<int> words;
std::vector<int> counts;
inline int d
浏览 4提问于2013-04-18得票数 0
1回答
我在尝试导出一个内联函数。我认为它应该如何运作：
//a.cpp
inline void f(int) {}
//b.cpp
extern void f(int);
int main() { f(4); }
但是得到链接错误。然后通过阅读 ("1)，必须在每个翻译单元中声明inline。“)。我试过的是：
//a.cpp
inline void f(int) {}
//b.cpp
extern inline void f(int);
int main() { f(4); }
仍然有链接错误。但现在，我不知道自己在做什么：
//a.cpp
extern inline void f(int
浏览 0提问于2019-05-28得票数 6
回答已采纳
我不是在问为什么或何时应该在某些代码中使用inline。
我在我认为很常见的地方使用inline (就像在get/set函数中)。我在堆栈上看到了一些不寻常的例子，其中inline听起来是必要的。我不确定在我的代码中我是否能认出这样的情况.我是说，在我有问题之前.
所以我想知道在通常情况下编译器是否能像我一样处理这个问题，也许更好.
我想避免使用inline的原因是为了避免在头文件中实现.关于这一点，我脑海中闪现出一个问题：
编译器(我一直认为GCC编译器在我的问题中)能够inline一个函数没有实现在标题？
n.b.：我不知道inline在C++14中是否有一些内部变化。
浏览 5提问于2015-08-30得票数 2
回答已采纳
我找到了以下函数定义：
static inline __attribute__((always_inline)) int fn(const char *s)
{
return (!s || (*s == '\0'));
}
我想知道inline __attribute__((always_inline))是什么意思
浏览 4提问于2014-04-01得票数 25
回答已采纳
1回答
我读过很多关于Kotlin inline关键字的文章和问题&就像过去一样，在使用它之前，我总是停下来想一想它是否适用于我正在编写的代码。
据我所知，简单地说，inline关键字的作用是:编译器不是创建函数对象和生成调用，而是复制代码块并将其放在我们希望调用该代码的位置。好处是:更好的内存分配。
因此，它的使用主要(如果不是总是的话)与高阶函数和Lambdas有关。
直到现在，我才开始研究Kotlin扩展函数是如何实现的。
下面是一些例子：
/**
* Returns a random element from this collection.
*
* @throws NoSuc
浏览 9提问于2022-10-02得票数 0
为什么我要在第2-6行中得到这个编译器警告消息？
警告C4244：“返回”：将“双”转换为“浮动”，可能会丢失数据
inline float SIGN(const double &a, const float &b)
{return b >= 0 ? (a >= 0 ? a : -a) : (a >= 0 ? -a : a);}
inline float pow (float x, double y) {return pow(double(x),y);}
inline float pow (double x, float y) {return pow(
浏览 11提问于2022-10-10得票数 0
回答已采纳
2回答
我们不需要显式声明内联函数，因为它们的实现是在头文件中定义的。但为了组织的目的，我想这么做。例如
// Group declaration firstly for readability.
inline void fooA();
inline void fooB();
inline void fooC();
...
// Implementations
inline void fooA()
{
...
}
inline void fooB()
{
...
}
inline void fooC()
{
...
}
我的问题是:在声明和实现中是否需要两个inline关键字，
浏览 2提问于2014-03-27得票数 2
回答已采纳
3回答
编译器如何计算哪些函数应该是内联的，因为内联请求不是必需的？我应该做什么样的功能内联？
额外问题。我可以打个内联电话吗？
void func{} // normal (not-inline) function
int main()
{
func(); // normal call
// inline func(); // inline call
return 0;
}
浏览 2提问于2014-01-16得票数 0
回答已采纳
我有一个程序，我想介绍一下。但是，它有一些使用属性gnu_inline声明的函数。如果我试图使用-finstrument-function标志构建程序，就会得到链接器错误，例如：
#define always_inline __attribute__((always_inline, gnu_inline))
static int inline always_inline f()
{
return 0;
}
int main(int argc, char *argv[])
{
int i = f();
return i;
}
给出“f()的未定义引用”错误。问题是编译
浏览 2提问于2014-01-03得票数 1
回答已采纳
4回答
如果inline模板函数包含在多个cpp文件中，我还需要它们吗？谢谢。
template<bool> inline QString GetText();
template<> inline QString GetText<true>() {return "true";}
template<> inline QString GetText<false>() {return "false";}
浏览 15提问于2013-07-16得票数 38
回答已采纳
我定义了类int2_、float2_和double2_，以处理C++和CUDA中的复杂算术。我想重载操作符=，以便对上述类的对象以及int、float和double类型的对象进行混合赋值。
我的执行情况如下：
class float2_;
class double2_;
class int2_ {
public:
int x;
int y;
int2_() : x(), y() {}
__host__ __device__ inline const int2_& operator=(const int a)
浏览 1提问于2013-04-15得票数 0
回答已采纳
我提出了一个关于内联定义在不同文件中的函数的奇怪问题。考虑以下场景。
在main.c中：
#include "inline.h"
int main(void) {
int i = 0;
for (i = 0; i<=100000; i++) {
omfg(i);
}
return 0;
}
在inline.h中：
inline int omfg(unsigned int num);
在inline.c中：
#include <stdio.h>
inline int omfg(unsigned int num)
浏览 2提问于2011-06-22得票数 3
回答已采纳
我是C++的入门级。尝试构建一个不是我创建的项目。在插入了一些缺少的库之后，我遇到了C2280错误：' CBrush ::CBrush(const CBrush &)'：正在尝试引用一个已删除的函数。我对如何开始弄清楚这个问题感到困惑。
static COLORREF ClrList[] = { RGB(128,0,0), // Red
RGB(128,128,0), // Dark yellow
RGB(0,200,0),
浏览 3提问于2021-09-10得票数 0
3回答
无指针函数可以内联吗？
、、、
let inline myfunction x y = ...
let inline mycurried = myfunction x // error, only functions may be marked inline
显式地inline库函数似乎是不可能的。所以无论何时调用mycurried，它都不会得到inlined，即使myfunction是正确的inlined，对吗？
那么，这可以被认为是curried函数的缺点之一吗？
浏览 1提问于2012-09-21得票数 6
回答已采纳
1回答
我正在试图编译以下代码：
#include <iostream>
extern "C" {
inline void blah() {
std::cout << "123" << std::endl;
};
}
namespace NN {
extern "C" {
inline void blah() {
std::cout << "123" << std::endl;
};
}
}
int main() {
blah();
retu
浏览 0提问于2014-07-22得票数 1
回答已采纳
class NullTimer {
public:
inline static bool changePeriod (const size_t) { return false; }
inline static void dispose (void) {}
inline static bool isActive (void) { return false; }
inline static void reset (void) {}
inline static void start (void) {}
inline static void stop (void) {}
};
浏览 1提问于2019-03-27得票数 2
回答已采纳
我在堆栈溢出中读到了一些关于C中的inline的问题，但仍然不清楚。
static inline void f(void) {}与static void f(void) {}没有实际差异。
C中的inline void f(void) {}并不像C++那样工作。它在C中是如何工作的？
extern inline void f(void);实际上是做什么的？
在我的C程序中，我从未真正找到inline关键字的用法，当我在其他人的代码中看到这个关键字时，它几乎总是static inline，在这个关键字中，我只看到了static。
浏览 3提问于2015-06-29得票数 75
回答已采纳
当文件包含extern inline声明时，C编译器是如何进行内联的？
我在StackOverflow上读过几篇关于extern inline的文章，但我还是不太明白下面的模式是如何工作的。一些帖子说，我们需要在头文件中有内联定义，然后在源文件中有相应的extern inline声明，如下面所示。
F.h：
inline void foo(void) { ... }
F.c：
#include "foo.h"
extern inline void foo(void);
int main(void) {
foo();
}
我的问题是编译器在使用类似的-O1标志编译时如何执行内
浏览 2提问于2021-12-28得票数 1
我当时正在读ODR，按照规则，"In the entire program, an object or non-inline function cannot have more than one definition"和我尝试了以下步骤.
file1.cpp
#include <iostream>
using namespace std;
inline int func1(void){ return 5; }
inline int func2(void){ return 6; }
inline int func3(void){ return 7; }
int su
浏览 1提问于2016-09-23得票数 18
回答已采纳
inline void t1();
void t1(){} // t1 is still inline?
void t2();
inline void t2(){} // t2 is inline?
static void t3(){}
inline void t3(); // t3 is still static?
inline void t4();
static void t4(){} // t4 is still inline?
// "inline function 't4' declared but n
浏览 4提问于2021-07-22得票数 0
回答已采纳
我在Clojure的源代码中看到了这个代码片段：
(defn ==
"Returns non-nil if nums all have the equivalent
value (type-independent), otherwise false"
{:inline (fn [x y] `(. clojure.lang.Numbers (equiv ~x ~y)))
:inline-arities #{2}
:added "1.0"}
.....
:inline是做什么的？
更新：也找到了很好的示例。
浏览 2提问于2017-05-30得票数 11
回答已采纳
5回答
使用inline关键字有两个含义(§7.1.3/4)：
它暗示编译器在调用点对函数体的替换优于通常的函数调用mechanism.Even，如果省略内联替换，则遵循内联的其他规则(特别是w.r.t一个定义规则)。
通常，如果需要的话，任何主流编译器都会在调用时替换函数体，因此只标记函数inline并不是真正需要的#1。
进一步的w.r.t #2，正如我所理解的，当您将一个函数声明为static inline函数时，
函数上的static关键字强制inline函数具有内部链接(内联函数具有外部链接)，这类函数的每个实例都被视为单独的函数(每个函数的地址不同)，这些函数的每个实例都有自己的静态局部变
浏览 5提问于2012-06-04得票数 90
回答已采纳
4回答
以下代码可以很好地编译：
g++ -std=c++11 test.cpp -Wall -Wextra -Wfatal-errors && ./a.out
但是，如果我从{*this}中删除花括号，而改用*this，我将面临错误：
错误:使用已删除的函数‘Obj：：Position：：Position(Obj：：Position&&)’
{*this}和*this之间的区别是什么
class Obj
{
template<bool> friend class Position;
double data;
public:
cl
浏览 31提问于2017-08-08得票数 51
回答已采纳
async def on_message(message):
if message.content.startswith('.info'):
embedVar = discord.Embed(title="Prices", description="T", color=246482)
embedVar.add_field(name="e", value="e", inline=False)
embedVar.add_field(name="e"
浏览 2提问于2021-06-20得票数 0
回答已采纳
我想输入一个函数f(x，y(x))，它的一般形式是f(x，y(x)) = g(x) + w(x)y。然后，我想把g函数和w函数分开，但是仍然用x来表示。
我使用了以下代码：
function [G,W] = create_fxy(f)
syms x
y=inline(f);
G_1=y(x,0);
syms y
W_1=diff(f,y,1);
W=inline(W_1)
G=inline(G_1);
end
它工作得很好，但是当我尝试输入像：$sen(x) + cos(x)y$这样的函数时，它会显示以下错误
Error usin
浏览 2提问于2016-10-12得票数 0
回答已采纳
test.cpp
#include <iostream>
void f()
{
std::cout<<"non-inline"<<std::endl;
}
main.cpp
#include <iostream>
using namespace std;
inline void f()
{
cout<<"inline"<<endl;
}
int main()
{
f();
return 0;
}
在调试模式下，输出为: non-inline。command:
浏览 4提问于2013-09-05得票数 0
1回答
VS2019中内联函数的几个问题
、、、、
我正在做一些(可能是异国情调的)关于C++内联函数在VS2019中的实验：
source1：
#include "pch.h"
inline int inline_func(int i) {
return i;
}
void testinline1()
{
inline_func(0);
}
source2：
#include "pch.h"
inline int inline_func(int i) {
return i*i ;
}
void testinline2()
{
inline_func(0);
}
主要来
浏览 5提问于2019-12-09得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
腾讯会议
实时音视频活动推荐
腾讯云开发者
