I&#39;m having trouble displaying a Base64 image inline.

How can I do it?

    &lt;!DOCTYPE html&gt;
    &lt;html&gt;
      &lt;head&gt;
        &lt;title&gt;Display Image&lt;/title&gt;
      &lt;/head&gt;
      &lt;body&gt;
        &lt;img style=&#39;display:block; width:100px;height:100px;&#39; id=&#39;base64image&#39;
           src=&#39;data:image/jpeg;base64, LzlqLzRBQ... &lt;!-- Base64 data --&gt;&#39; /&gt;
      &lt;/body&gt;
    &lt;/html&gt;



How to display Base64 images in HTML

When should I write the keyword `inline` for a function/method in C++?

After seeing some answers, some related questions:

 - When should I **not** write the keyword &#39;inline&#39; for a function/method in C++?

 - When will the compiler not know when to make a function/method &#39;inline&#39;?

 - Does it matter if an application is **multithreaded** when one writes &#39;inline&#39; for a function/method?

When should I write the keyword &#39;inline&#39; for a function/method?

I need to print some stuff only when a boolean variable is set to `True`. So, after looking at [this][1], I tried with a simple example:

    &gt;&gt;&gt; a = 100
    &gt;&gt;&gt; b = True
    &gt;&gt;&gt; print a if b
      File &quot;&lt;stdin&gt;&quot;, line 1
        print a if b
                 ^
    SyntaxError: invalid syntax  

Same thing if I write `print a if b==True`.

What am I missing here?


  [1]: https://stackoverflow.com/questions/1319214/shorter-more-pythonic-way-of-writing-an-if-statements

How to write inline if statement for print?

How do you do &quot;inline functions&quot; in C#? I don&#39;t think I understand the concept. Are they like anonymous methods? Like lambda functions?

**Note**: The answers almost entirely deal with the ability to [inline functions][1], i.e. &quot;a manual or compiler optimization that replaces a function call site with the body of the callee.&quot; If you are interested in [anonymous (a.k.a. lambda) functions][2], see [@jalf&#39;s answer][3] or https://stackoverflow.com/questions/1085875/what-is-this-lambda-everyone-keeps-speaking-of/1086347#1086347.


  [1]: http://en.wikipedia.org/wiki/Inline_expansion
  [2]: http://en.wikipedia.org/wiki/Anonymous_function
  [3]: https://stackoverflow.com/a/473813/116891

Inline functions in C#?

I know that inline is a hint or request to compiler and its used to avoid function call overheads.

So on what basis one can determine whether a function is a candidate for inlining or not ?
In which case one should avoid inlining ?


When to use inline function and when not to use it?

I got this question when I received a code review comment saying virtual functions need not be inline. 

I thought inline virtual functions could come in handy in scenarios where functions are called on objects directly. But the counter-argument came to my mind is -- why would one want to define virtual and then use objects to call methods?

Is it best not to use inline virtual functions, since they&#39;re almost never expanded anyway?

Code snippet I used for analysis:


    class Temp
    {
    public:
    
    	virtual ~Temp()
    	{
    	}
    	virtual void myVirtualFunction() const
    	{
    		cout&lt;&lt;&quot;Temp::myVirtualFunction&quot;&lt;&lt;endl;
    	}
    
    };
    
    class TempDerived : public Temp
    {
    public:
    	
    	void myVirtualFunction() const
    	{
    		cout&lt;&lt;&quot;TempDerived::myVirtualFunction&quot;&lt;&lt;endl;
    	}
    
    };
    
    int main(void) 
    {
    	TempDerived aDerivedObj;
    	//Compiler thinks it&#39;s safe to expand the virtual functions
    	aDerivedObj.myVirtualFunction();
    
    	//type of object Temp points to is always known;
        //does compiler still expand virtual functions?
    	//I doubt compiler would be this much intelligent!
    	Temp* pTemp = &amp;aDerivedObj;
    	pTemp-&gt;myVirtualFunction();
    
    	return 0;
    }



Are inline virtual functions really a non-sense?

&lt;!-- language: lang-javascript --&gt;

	// this e works
	document.getElementById(&quot;p&quot;).oncontextmenu = function(e) {
		e = e || window.event;
		var target = e.target || e.srcElement;
		console.log(target);
	};

	// this e is undefined
	function doSomething(e) {
		e = e || window.event;
		var target = e.target || e.srcElement;
		console.log(target);
	}

&lt;!-- language: lang-html --&gt;

	&lt;p id=&quot;p&quot; onclick=&quot;doSomething(e)&quot;&gt;
		&lt;a href=&quot;#&quot;&gt;foo&lt;/a&gt;
		&lt;span&gt;bar&lt;/span&gt;
	&lt;/p&gt;

There are some similar questions have been asked.

But in my code, **I&#39;m trying to get child elements who&#39;s been clicked, like `a` or `span`**.

So what is the correct way to pass `event` as an argument to event handler, or how to get event inside handler without passing an argument?

edit
====

I&#39;m aware of `addEventListener` and `jQuery`, please provide a solution for passing event to `inline` event hander.

How to pass event as argument to an inline event handler in JavaScript?

IMO both make the function to have a scope of the translation unit only.

What&#39;s the difference between &quot;static&quot; and &quot;static inline&quot; function?

Why should `inline` be put in a header file, not in `.c` file?


What&#39;s the difference between &quot;static&quot; and &quot;static inline&quot; function?

Say I have this small function in a source file

    static void foo() {}

and I build an optimized version of my binary yet I don&#39;t want this function inlined (for optimization purposes). is there a macro I can add in a source code to prevent the inlining?

How can I tell gcc not to inline a function?

&lt;sub&gt;&lt;b&gt;NB&lt;/b&gt; This is not a question about how to use inline functions or how they work, more why they are done the way they are.&lt;/sub&gt;

The declaration of a class member function does not need to define a function as `inline`, it is only the actual implementation of the function.  For example, in the header file:

&lt;!-- language: lang-cpp --&gt;

    struct foo{
        void bar(); // no need to define this as inline
    }

So why does the inline implementation of a classes function *have* to be in the header file? Why can&#39;t I put the inline function the `.cpp` file? If I were to try to put the inline definition in the `.cpp` file I would get an error along the lines of:

&lt;!-- language: none --&gt;

    error LNK2019: unresolved external symbol 
    &quot;public: void __thiscall foo::bar(void)&quot;
    (?bar@foo@@QAEXXZ) referenced in function _main 
    1&gt;C:\Users\Me\Documents\Visual Studio 2012\Projects\inline\Debug\inline.exe 
    : fatal error LNK1120: 1 unresolved externals

Why are C++ inline functions in the header?

Since templates are defined within headers and compiler is able to determine if inlining a function is advantageous, does it make any sense? I&#39;ve heard that modern compilers know better when to inline a function and are ignoring `inline` hint.

---
edit: I would like to accept both answers, but this is not possible. To close the issue I am accepting **Sebastian Mach**&#39;s answer, because it received most votes and he is formally right, but as I mentioned in comments I consider **Puppy**&#39;s and **Component 10**&#39;s answers as correct ones too, from different point of view.

The problem is in C++ semantics, which is not strict in case of `inline` keyword and inlining. **Sebastian Mach** says &quot;write inline if you mean it&quot;, but what is actually meant by `inline` is not clear as it evolved from its original meaning to a directive that &quot;stops compilers bitching about ODR violations&quot; as **Puppy** says.

Does it make any sense to use inline keyword with templates?

Consider the following inlined function :

    // Inline specifier version
    #include&lt;iostream&gt;
    #include&lt;cstdlib&gt;
    
    inline int f(const int x);
    
    inline int f(const int x)
    {
        return 2*x;
    }
    
    int main(int argc, char* argv[])
    {
        return f(std::atoi(argv[1]));
    }

and the constexpr equivalent version :

    // Constexpr specifier version
    #include&lt;iostream&gt;
    #include&lt;cstdlib&gt;
    
    constexpr int f(const int x);
    
    constexpr int f(const int x)
    {
        return 2*x;
    }
    
    int main(int argc, char* argv[])
    {
        return f(std::atoi(argv[1]));
    }

My question is : does the `constexpr` specifier imply the `inline` specifier in the sense that if a non-constant argument is passed to a `constexpr` function, the compiler will try to `inline` the function as if the `inline` specifier was put in its declaration ?

Does the C++11 standard guarantee that ?




Does constexpr imply inline?

I would like to know if there is a better way to conditionally pass a prop than using an if-statement. 

For example, right now I have:

    var parent = React.createClass({
      propTypes: {
        editable: React.PropTypes.bool.isRequired,
        editableOpts: React.PropTypes.shape({...})
      },
      render: function() {
        if(this.props.editable) {
          return (
            &lt;Child editable={this.props.editableOpts} /&gt;
          );
        } else {
          // In this case, Child will use the editableOpts from its own getDefaultProps()
          return (
            &lt;Child /&gt;
          );
        }
      }
    });

Is there a way to write this without the if-statement? I am was thinking something along the lines of a type of inline-if-statement in the JSX:

    var parent = React.createClass({
      propTypes: {
        editable: React.PropTypes.bool.isRequired,
        editableOpts: React.PropTypes.shape({...})
      },
      render: function() {
        return (
          &lt;Child 
            {this.props.editable ? editable={this.props.editableOpts} : null} 
          /&gt;
        );
      }
    });

_To wrap-up_: I&#39;m trying to find a way to define a prop for `Child`, but pass a value (or do something else) such that `Child` still pulls that prop&#39;s value from `Child`&#39;s own `getDefaultProps()`.

React: inline conditionally pass prop to component

How does an inline function differ from a preprocessor macro?

Inline functions vs Preprocessor macros

Having an issue sending an image via email as an embedded image in the body.
The image file shows as an attachment which is ok but the inline image portion just shows as a red x.

Here is what I have so far

    LinkedResource inline = new LinkedResource(filePath);
    inline.ContentId = Guid.NewGuid().ToString();
    MailMessage mail = new MailMessage();
    Attachment att = new Attachment(filePath);
    att.ContentDisposition.Inline = true;
    mail.From = from_email;
    mail.To.Add(data.email);
    mail.Subject = &quot;Client: &quot; + data.client_id + &quot; Has Sent You A Screenshot&quot;;
    mail.Body = String.Format(
        &quot;&lt;h3&gt;Client: &quot; + data.client_id + &quot; Has Sent You A Screenshot&lt;/h3&gt;&quot; +
        @&quot;&lt;img src=&quot;&quot;cid:{0}&quot;&quot; /&gt;&quot;, inline.ContentId);

    mail.IsBodyHtml = true;
    mail.Attachments.Add(att);

Send inline image in email

A Levenshtein implementation in C# and F#. The C# version is 10 times faster for two strings of about 1500 chars. C#: 69 ms, F# 867 ms. Why? As far as I can tell, they do the exact same thing? Doesn&#39;t matter if it is a Release or a Debug build. 

EDIT: If anyone comes here looking specifically for the Edit Distance implementation, it is broken. Working code is [here](https://bitbucket.org/vgrit/clrsquirrel/src/82840c2ce95b/ClrSquirrel/ClrSquirrel.fs).

**C#**:

&lt;!-- language: lang-cs --&gt;

    private static int min3(int a, int b, int c)
    {
       return Math.Min(Math.Min(a, b), c);
    }

    public static int EditDistance(string m, string n)
    {
       var d1 = new int[n.Length];
       for (int x = 0; x &lt; d1.Length; x++) d1[x] = x;
       var d0 = new int[n.Length];
       for(int i = 1; i &lt; m.Length; i++)
       {
          d0[0] = i;
          var ui = m[i];
          for (int j = 1; j &lt; n.Length; j++ )
          {
             d0[j] = 1 + min3(d1[j], d0[j - 1], d1[j - 1] + (ui == n[j] ? -1 : 0));
          }
          Array.Copy(d0, d1, d1.Length);
       }
       return d0[n.Length - 1];
    }

**F#**:

&lt;!-- language: lang-ml --&gt;

    let min3(a, b, c) = min a (min b c)

    let levenshtein (m:string) (n:string) =
       let d1 = Array.init n.Length id
       let d0 = Array.create n.Length 0
       for i=1 to m.Length-1 do
          d0.[0] &lt;- i
          let ui = m.[i]
          for j=1 to n.Length-1 do
             d0.[j] &lt;- 1 + min3(d1.[j], d0.[j-1], d1.[j-1] + if ui = n.[j] then -1 else 0)
          Array.blit d0 0 d1 0 n.Length
       d0.[n.Length-1]

Why is this F# code so slow?

I have the below message (slightly changed):

&gt; &quot;Enter the competition by January 30, 2011 and you could win up to
&gt; $$$$ — including amazing summer trips!&quot;

I currently have:

    &lt;p style=&quot;font-size:14px; color:#538b01; font-weight:bold; font-style:italic;&quot;&gt;

formatting the text string, but want to change the color of &quot;January 30, 2011&quot; to #FF0000 and &quot;summer&quot; to #0000A0. 

How do I do this strictly with HTML or inline CSS?

HTML: Changing colors of specific words in a string of text

When I try to build this code

    inline void f() {}
    
    int main()
    {
        f();
    }

using the command line

    gcc -std=c99 -o a a.c

I get a linker error (undefined reference to `f`).  The error vanishes if I use `static inline` or `extern inline` instead of just `inline`, or if I compile with `-O` (so the function is actually inlined).

This behaviour seems to be defined in paragraph 6.7.4 (6) of the C99 standard:
&gt; If all of the file scope declarations for a function in a translation unit include the `inline` function specifier without `extern`, then the definition in that translation unit is an inline definition. An inline definition does not provide an external definition for the function, and does not forbid an external definition in another translation unit. An inline definition provides an alternative to an external definition, which a translator may use to implement any call to the function in the same translation unit. It is unspecified whether a call to the function uses the inline definition or the external definition.

If I understand all this correctly, a compilation unit with a function defined `inline` as in the above example only compiles consistently if there is also an external function with the same name, and I never know if my own function or the external function is called.

Isn&#39;t this behaviour completely daft? Is it ever useful to define a function `inline` without `static` or `extern` in C99?  Am I missing something?

## Summary of answers

Of course I was missing something, and the behaviour isn&#39;t daft. :)

As [Nemo explains](https://stackoverflow.com/questions/6312597/is-inline-without-static-or-extern-ever-useful-in-c99/6312813#6312813), the idea is to put the *definition* of the function

    inline void f() {}

in the header file and only a *declaration*

    extern inline void f();

in the corresponding .c file.  Only the `extern` declaration triggers the generation of externally visible binary code.  And there is indeed no use of `inline` in a .c file -- it&#39;s only useful in headers.

As the [rationale of the C99 committee quoted in Jonathan&#39;s answer](https://stackoverflow.com/questions/6312597/is-inline-without-static-or-extern-ever-useful-in-c99/6312854#6312854) explicates, `inline` is all about compiler optimisations that require the definition of a function to be visible at the site of a call.  This can only be achieved by putting the definition in the header, and of course a definition in a header must not emit code every time it is seen by the compiler.  But since the compiler is not forced to actually inline a function, an external definition must exist somewhere.

Is &quot;inline&quot; without &quot;static&quot; or &quot;extern&quot; ever useful in C99?

Rust has an &quot;inline&quot; attribute that can be used in one of those three flavors:

`#[inline]`

`#[inline(always)]`

`#[inline(never)]`

When should they be used?

In the Rust reference, we see [an inline attributes section][1] saying

&gt; The compiler automatically inlines functions based on internal heuristics. Incorrectly inlining functions can actually make the program slower, so it should be used with care.

In the Rust internals forum, huon was also [conservative about specifying inline][2].

But we see [considerable usage][3] in the Rust source, including the standard library. A lot of inline attributes are added to one-line-functions, which should be easy for the compilers to spot and optimize through heuristics according to the reference. Are those in fact not needed?


  [1]: https://doc.rust-lang.org/reference.html#inline-attributes
  [2]: https://internals.rust-lang.org/t/when-should-i-use-inline/598/3?u=wisagan
  [3]: https://github.com/rust-lang/rust/search?utf8=%E2%9C%93&amp;q=inline&amp;type=Code

When should inline be used in Rust?

I am a JAVA developer who is trying to learn C++, but I don&#39;t really know what the best practice is for standard function declarations.

In the class:

    class Clazz
    {
     public:
        void Fun1()
        {
            //do something
        }
    }

Or outside:

    class Clazz
    {
    public:
        void Fun1();
    }
    
    Clazz::Fun1(){
        // Do something
    }

I have a feeling that the second one can be less readable...


Function declaration inside or outside the class

Is there a Python argument to execute code from the shell without starting up an interactive interpreter or reading from a file? 
Something similar to:


    perl -e &#39;print &quot;Hi&quot;&#39;

How to execute Python inline from a bash shell

If I have the following in my html:

    &lt;div style=&quot;height:300px; width:300px; background-color:#ffffff;&quot;&gt;&lt;/div&gt;

And this in my css style sheet:

    div {
        width:100px;
        height:100px;
        background-color:#000000;
    }

Is there any way, with javascript/jquery, to remove all of the inline styles and leave only the styles specified by the css style sheet?

How can I erase all inline styles with javascript and leave only the styles specified in the css style sheet?

I generated a bubble chat thingy from http://www.ilikepixels.co.uk/drop/bubbler/

In my page I put a number inside of it

    .bubble {
      position: relative;
      width: 20px;
      height: 15px;
      padding: 0;
      background: #FFF;
      border: 1px solid #000;
      border-radius: 5px;
    }
    
    .bubble:after {
      content: &quot;&quot;;
      position: absolute;
      top: 4px;
      left: -4px;
      border-style: solid;
      border-width: 3px 4px 3px 0;
      border-color: transparent #FFF;
       display: block;
      width: 0;
      z-index: 1;
    }
    
    .bubble:before {
      content: &quot;&quot;;
      position: absolute;
      top: 4px;
      left: -5px;
      border-style: solid;
      border-width: 3px 4px 3px 0;
      border-color: transparent #000;
      display: block;
      width: 0;
      z-index: 0;
    }


I want the `background-color` of the bubble to change according to the number inside of it via `rgb`

so if my div is

    &lt;div class=&quot;bubble&quot; style=&quot;background-color: rgb(100,255,255);&quot;&gt; 100 &lt;/div&gt;
I want the color to be `rgb(100,255,255)`

The thing is this doesn&#39;t affect the triangle.

How do I write the inline css so it will include the :before and :after?

how to create inline style with :before and :after

I believed, `inline` was obsolete because I read [here](https://isocpp.org/wiki/faq/inline-functions):

&gt; No matter how you designate a function as `inline`, it is a request that the compiler is allowed to ignore: the compiler might inline-expand some, all, or none of the places where you call a function designated as `inline`.

However, [Angew](https://stackoverflow.com/users/1782465/angew) seems to understand something I don&#39;t. In [this question](https://stackoverflow.com/q/29771146/2642059) he and I go back and forth quite a bit, on whether `inline` is still useful.

This question is *not* a question on:

 * The historical use of `inline` or where `inline` could still be used to hint to the compiler to `inline` functions: https://stackoverflow.com/questions/1759300/when-should-i-write-the-keyword-inline-for-a-function-method.
 * The benefits or drawbacks of inlining function code: https://stackoverflow.com/q/145838/2642059
 * Forcing the compiler to `inline` function code: https://stackoverflow.com/q/13228326/2642059

Bearing in mind that the compiler can `inline` at will, so `inline` is not helpful there: **Where can `inline` be used to force, *not suggest*, a change in compiled code?**

Is there still a use for inline?

    public:
         inline int GetValue() const {
              return m_nValue;
         }
         inline void SetValue(int nNewValue) {
              this -&gt; m_nValue = nNewValue;
         }

On _Learn C++_, they said it would run faster. So, I thought it would be great to use on getters and setters. But maybe, there are some drawbacks to it?

Is it good practice to make getters and setters inline?

I am trying to simplify the following code.

The basic steps that the code should carry out are as follows:

 1. Assign String a default value 
 2. Run a method 
 3. If the method returns a null/empty string leave the String as default 
 4. If the method returns a valid string set the String to this result

A Simple example would be:

        String temp = System.getProperty(&quot;XYZ&quot;);
        String result = &quot;default&quot;;
        if(temp != null &amp;&amp; !temp.isEmpty()){
            result = temp;
        }
I have made another attemp using a ternary operator:

        String temp;
        String result = isNotNullOrEmpty(temp = System.getProperty(&quot;XYZ&quot;)) ? temp : &quot;default&quot;;

The isNotNullOrEmpty() Method

     private static boolean isNotNullOrEmpty(String str){
        return (str != null &amp;&amp; !str.isEmpty());
    }

Is it possible to do all of this in-line? I know I could do something like this:

    String result = isNotNullOrEmpty(System.getProperty(&quot;XYZ&quot;)) ? System.getProperty(&quot;XYZ&quot;) : &quot;default&quot;;

But I am calling the same method twice. I would be something like to do something like this (which doesn&#39;t work):

    String result = isNotNullOrEmpty(String temp = System.getProperty(&quot;XYZ&quot;)) ? temp : &quot;default&quot;;

I would like to initialize the &#39;temp&#39; String within the same line. Is this possible? Or what should I be doing?

Thank you for your suggestions.

Tim

Java - Check Not Null/Empty else assign default value

There are two implications of using the `inline` keyword(&#167; 7.1.3/4):

 1. It *hints* the compiler that substitution of function body at the point of call is preferable over the usual function call mechanism.
 2. Even if the inline substitution is omitted, the other rules(especially w.r.t *One Definition Rule*) for inline are followed.

Usually any mainstream compiler will substitute function body at the point of call if needed, so marking function `inline` merely for `#1` is not really needed.

Further w.r.t `#2`, As I understand when you declare a function as `static inline` function, 

The `static` keyword on the function forces the `inline` function to have an internal linkage(*inline functions have external linkage*) Each instance of such a function is treated as a separate function(*address of each function is different*) and each instance of these functions have their own copies of static local variables &amp; string literals(*an inline function has only one copy of these*)

Thus such a function acts like any other `static` function and the keyword `inline` has no importance anymore, it becomes redundant.

So, Practically marking a function `static` and `inline` both has no use at all. Either it should be `static`(*not most preferred*) or `inline`(*most preferred*),    
So, Is using `static` and `inline` together on a function *practically* useless?

Should one never use static inline function?

The logic is of the model is:  

 - A `Building` has many `Rooms`
 - A `Room` may be inside another `Room` (a closet, for instance--ForeignKey on &#39;self&#39;)  
 - A `Room` can only be inside another `Room` in the same building (this is the tricky part)  
  
Here&#39;s the code I have:  

    #spaces/models.py
    from django.db import models    
    
    class Building(models.Model):
        name=models.CharField(max_length=32)
        def __unicode__(self):
            return self.name

    class Room(models.Model):
        number=models.CharField(max_length=8)
        building=models.ForeignKey(Building)
        inside_room=models.ForeignKey(&#39;self&#39;,blank=True,null=True)
        def __unicode__(self):
            return self.number

and:

    #spaces/admin.py
    from ex.spaces.models import Building, Room
    from django.contrib import admin
    
    class RoomAdmin(admin.ModelAdmin):
        pass

    class RoomInline(admin.TabularInline):
        model = Room
        extra = 2

    class BuildingAdmin(admin.ModelAdmin):
        inlines=[RoomInline]

    admin.site.register(Building, BuildingAdmin)
    admin.site.register(Room)


The inline will display only rooms in the current building (which is what I want).  The problem, though, is that for the `inside_room` drop down, it displays all of the rooms in the Rooms table (including those in other buildings).


In the inline of `rooms`, I need to limit the `inside_room` choices to only `rooms` which are in the current `building` (the building record currently being altered by the main `BuildingAdmin` form). 


I can&#39;t figure out a way to do it with either a `limit_choices_to` in the model, nor can I figure out how exactly to override the admin&#39;s inline formset properly (I feel like I should be somehow create a custom inline form, pass the building_id of the main form to the custom inline, then limit the queryset for the field&#39;s choices based on that--but I just can&#39;t wrap my head around how to do it).

Maybe this is too complex for the admin site, but it seems like something that would be generally useful... 


Limit foreign key choices in select in an inline form in admin

Why should i do something like this:

    inline double square (double x) { return x*x;}

instead of 

    double square (double x) { return x*x;}

Is there a difference?

c++ inline function?

I know that inline member functions by definition should go into the header. But what if it&#39;s not possible to put the implementation of the function into the header? Let&#39;s take this situation:


File A.h
    
    #pragma once
    #include &quot;B.h&quot;

    class A{
        B b;
    };


File B.h

    #pragma once

    class A; //forward declaration

    class B{
        inline A getA();
    };

Due to the circular include I have to put the implementation of `getA` into

B.cpp

    #include &quot;B.h&quot;
    #include &quot;A.h&quot;

    inline A B::getA(){
        return A();
    }


Will the compiler inline `getA`? If so, which inline keyword is the significant one (the one in the header or the one in the .cpp file)? Is there another way to put the definition of an inline member function into its .cpp file?

C++ inline member function in .cpp file

What are the differences between these four inline (key)words?

`inline`, `__inline`, `__inline__`, `__forceinline`.

inline vs __inline vs __inline__ vs __forceinline?

The `inline` keyword in F# seems to me to have a somewhat different purpose than what I&#39;m used to in e.g. C. For example, it seems to affect a function&#39;s type (what are &quot;statically resolved type parameters&quot;? Aren&#39;t all F# types resolved statically?)

When should I be using `inline` functions?

Use of `inline` in F#

I am putting together the admin for a satchmo application. Satchmo uses OneToOne relations to extend the base `Product` model, and I&#39;d like to edit it all on one page.

It is possible to have a OneToOne relation as an Inline? If not, what is the best way to add a few fields to a given page of my admin that will eventually be saved into the OneToOne relation?

for example:

    class Product(models.Model):
        name = models.CharField(max_length=100)
        ...
    
    class MyProduct(models.Model):
        product = models.OneToOne(Product)
        ...


I tried this for my admin but it does not work, and seems to expect a Foreign Key:

    class ProductInline(admin.StackedInline):
        model = Product
        fields = (&#39;name&#39;,)
    
    class MyProductAdmin(admin.ModelAdmin):
        inlines = (AlbumProductInline,)
    
    admin.site.register(MyProduct, MyProductAdmin)

Which throws this error: `&lt;class &#39;satchmo.product.models.Product&#39;&gt; has no ForeignKey to &lt;class &#39;my_app.models.MyProduct&#39;&gt;`

Is the only way to do this a [Custom Form][1]?

**edit:** Just tried the following code to add the fields directly... also does not work:

    class AlbumAdmin(admin.ModelAdmin):
        fields = (&#39;product__name&#39;,)


  [1]: http://docs.djangoproject.com/en/dev/ref/contrib/admin/#form

Django Admin: OneToOne Relation as an Inline?

I want to create my first web page but I encountered a problem.

I have the following code:
    
    &lt;img src=&quot;img/logo.png&quot; alt=&quot;logo&quot; /&gt;
    &lt;h1&gt;My website name&lt;/h1&gt;

I&#39;d like to know how to make the logo and the H1 to be in the same line.
Thanks!

Logo image and H1 heading on the same line

Does `__attribute__((always_inline))` force a function to be inlined by gcc?

How do I force gcc to inline a function?

I was reading the C++ FAQs and I noticed one sentence.

&gt;main() cannot be inline. 

Why is this?


Why main() in C++ cannot be inlined?

I read several questions in stackoverflow about `inline` in C but still am not clear about it.

 1. `static inline void f(void) {}` has no practical difference with `static void f(void) {}`.
 2. `inline void f(void) {}` in C doesn&#39;t work as the C++ way. How does it work in C?
 3. What actually does `extern inline void f(void);` do?

I never really found a use of the `inline` keyword in my C programs, and when I see this keyword in other people&#39;s code, it&#39;s almost always `static inline`, in which I see no difference with just `static`.

What is the use of the `inline` keyword in C?

I am getting a really odd error from GCC 4.8.1 with inline functions.

I have two near-identical inline functions defined in header files (`debug.h` and `error.h`) in `src/include/`, with the only difference being what they print - one prefixes `DEBUG: ` to the message, and the other `%s: error: %s` (program name, error message). When defining the functions both inline, and compiling a debug build (so it sets the macro `DEBUG=1`), I get lots of undefined reference errors:

    src/main_debug.o
      gcc -osrc/main_debug.o src/main.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1 -DBTCWATCH_VERSION=&quot;\&quot;0.0.1\&quot;&quot;
    
    src/lib/btcapi_debug.o
      gcc -osrc/lib/btcapi_debug.o src/lib/btcapi.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1
    
    src/lib/libbtcapi_debug.a
      ar rc src/lib/libbtcapi_debug.a src/lib/btcapi_debug.o
      ranlib src/lib/libbtcapi_debug.a
    
    src/lib/cmdlineutils_debug.o
      gcc -o src/lib/cmdlineutils_debug.o src/lib/cmdlineutils.c -c -Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g -DCC=&quot;\&quot;gcc\&quot;&quot; -DCFLAGS=&quot;\&quot;-Wall -Wextra -Wpedantic -std=gnu11 -march=native -Og -g\&quot;&quot; -DDEBUG=1
    
    src/lib/libcmdlineutils_debug.a
      ar rc src/lib/libcmdlineutils_debug.a src/lib/cmdlineutils_debug.o
      ranlib src/lib/libcmdlineutils_debug.a
    
    debug
      gcc -obtcwatch-debug src/main_debug.o -Lsrc/lib/ -lbtcapi_debug -lcmdlineutils_debug -lcurl  -ljansson 
    src/main_debug.o: In function `main&#39;:
    /home/marcoms/btcwatch/src/main.c:148: undefined reference to `debug&#39;
    src/main_debug.o:/home/marcoms/btcwatch/src/main.c:185: more undefined references to `debug&#39; follow
    collect2: error: ld returned 1 exit status
    make: *** [debug] Error 1

But changing `debug()`&#39;s definition to `static inline` removes the errors. But I have never received any errors from `error()`&#39;s definition, although its defenition is `inline`, and not `static inline`.

The definitions are all in headers (i.e. not prototyped)

undefined reference when calling inline function

I try to build fluid layout using percentages as widths. Do do so i tried this:

    &lt;div style=&quot;width:50%; display:inline-table;&quot;&gt;A&lt;/div&gt;
    &lt;div style=&quot;width:50%; display:inline-table;&quot;&gt;B&lt;/div&gt;

In that case they wont stand in one line, but if i remove line break between them, like this:

        &lt;div style=&quot;width:50%; display:inline-table;&quot;&gt;A&lt;/div&gt;&lt;div style=&quot;width:50%;   display:inline-table;&quot;&gt;B&lt;/div&gt;

then it works fine. Where is the problem? How can i do someting like that but without using absolute position and float.

p.s. sorry for english.
p.s.s. i hope i good explain my problem 

CSS two div width 50% in one line with line break in file

In my scala code:

    QueueManager.add(getObject)

where `getObject` is a method that returns an object of type `QueueObject`.

    def getObject : QueuObject = {
        val response = //some response
        return response
    }

Is there a way I can check for the response being null, while adding the QueueObject? I know I can do this:

    if (getObject != null)
        QueueManager.add(getObject)

But I do not wish to add a level of indentation. Is there an operator that does that inline?

Thanks.

How to check for null in a single statement in scala?

How much faster is it to use a base64/line to display images than opposed to simply linking to the hard file on the server?

    url(data:image/png;base64,.......)

I haven&#39;t been able to find any type of performance metrics on this.

I have a few concerns:


 - You no longer gain the benefit of caching
 - Isn&#39;t a base64 A LOT larger in size than what a PNG/JPEG file size?

**Let&#39;s define &quot;faster&quot; as in: the time it takes for a user to see a full rendered HTML web page**

			

How much faster is it to use inline/base64 images for a web site than just linking to the hard file?

I&#39;m getting a compiler error when I try to inline a method of one of my classes. It works when I take away the &quot;inline&quot; keyword. 

Here&#39;s a simplified example:

**main.cpp:**

    #include &quot;my_class.h&quot;
    
    int main() {
      MyClass c;
      c.TestMethod();
    
      return 0;
    }

**my_class.h:**

    class MyClass {
     public:
      void TestMethod();
    };

**my_class.cpp:**

    #include &quot;my_class.h&quot;
    
    inline void MyClass::TestMethod() {
    }

I try compiling with:

    g++ main.cpp my_class.cpp

I get the error:

    main.cpp:(.text+0xd): undefined reference to `MyClass::TestMethod()&#39;

Everything is fine if I take away the &quot;inline&quot;. What&#39;s causing this problem? (and how should I inline class methods? Is it possible?)

Thanks.

C++ inlining class methods causes undefined reference

Is it possible to load an external font via inline CSS?

Note: I&#39;m *not* talking about using an external CSS file with a `@font-face` definition, but rather something like the following:

    &lt;h1 style=&quot;font-family:myfont;
        src:(&#39;http://example.com/font/myfont.tff&#39;)&quot;&gt;test&lt;/h1&gt;

Loading an external font via inline CSS

I have two questions:

1) Why are pointers to inline functions allowed in C++?
I have read that the code of inline functions just gets copied to the function call statement and there is no compile-time memory allocation in inline functions. So why can a pointer exist to an inline function, given that there is no fixed memory address for inline functions?

2) Consider the code below:

    inline void func()    
    {
        int n=0;
        cout&lt;&lt;(&amp;n);
    } 

Should it not print different values of the address of `n` each time `func()` is called? 
[Because I think that every time inline function code is copied, reallocation of the local variables must be done (whereas in the case of normal functions, reinitialisation takes place)]

I am a beginner and I asked this question for the sake of my concept strengthening. Please correct me if I am wrong anywhere.

Why are pointers to inline functions allowed?

### First off, I am *not* looking for a way to force the compiler to inline the implementation of every function.

To reduce the level of misguided answers make sure you understand what the `inline` keyword actually means.  Here is good description, [inline vs static vs extern][1].

So my question, why not mark every function definition `inline`?  ie  Ideally, the only compilation unit would be `main.cpp`.  Or possibly a few more for the functions that cannot be defined in a header file (pimpl idiom, etc).

The theory behind this odd request is it would give the optimizer maximum information to work with.  It could inline function implementations of course, but it could also do &quot;cross-module&quot; optimization as there is only one module.  Are there other advantages?

Has any one tried this in with a real application?  Did the performance increase? decrease?!?

What are the disadvantages of marking all function definitions `inline`?

* Compilation might be slower and will consume much more memory.
* Iterative builds are broken, the entire application will need to be rebuilt after every change.
* Link times might be astronomical

All of these disadvantage only effect the developer.  What are the runtime disadvantages?


  [1]: https://stackoverflow.com/questions/1759300/c-when-should-i-write-the-keyword-inline-for-a-function-method/1759575#1759575

Why not mark everything inline?

In the file `file1.c`, there is a call to a function that is implemented in the file `file2.c`.
When I link `file1.o` and `file2.o` into an executable, if the function in `file2` is very small, will the linker automatically detect that the function is small and inline its call?



All Inline Solutions on Gang of Coders

Total of 46 Inline Solutions