This is a common trick to make a &quot;reference type&quot; in C, where using it as a function argument causes the single element array to degrade to a pointer to its first element without the programmer needing to explicitly use the `&amp;` operator to get its address. Where declared, it&#39;s a real stack type (no dynamic allocation needed), but when passed as an argument, the called function receives a pointer to it, not a copy, so it&#39;s passed cheaply (and can be mutated by the called function if not `const`).

GMP uses the same trick with its `mpz_t` type, and it&#39;s critical there, because the structure manages a pointer to dynamically allocated memory; the `mpz_init` function relies on getting a pointer to the structure, not a copy of it, or it couldn&#39;t initialize it at all. Similarly, many operations can resize the dynamically allocated memory, and that wouldn&#39;t work if they couldn&#39;t mutate the caller&#39;s struct.

I can&#39;t inject MatDialogRef as it described in documentation: https://material.angular.io/components/dialog/overview

When i&#39;m trying to do it i&#39;v got error:

ERROR Error: StaticInjectorError[MatDialogRef]:
StaticInjectorError[MatDialogRef]:
NullInjectorError: No provider for MatDialogRef!

app.module.ts

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    import { NgModule }      from &#39;@angular/core&#39;;
    import { BrowserModule } from &#39;@angular/platform-browser&#39;;
    import { FormsModule }   from &#39;@angular/forms&#39;;

    import {
    	MatInputModule,
    	MatDialogModule,
    	MatProgressSpinnerModule,
    	MatButtonModule,
    	MatDialog,
    	MatDialogRef
    } from &#39;@angular/material&#39;;

    import { ApiModule } from &#39;../api/api.module&#39;;
    import { RoutingModule } from &#39;../routing/routing.module&#39;;

    import { RegistrationComponent } from &#39;./components/registration.component&#39;;
    import { LoginComponent } from &#39;./components/login.component&#39;;

    import { AccountService } from &#39;./services/account.service&#39;;

    @NgModule({
    	imports: [
    		BrowserModule,
    		MatInputModule,
    		MatDialogModule,
    		MatProgressSpinnerModule,
    		MatButtonModule,
    		FormsModule,
    		RoutingModule,
    		ApiModule
    	],
    	declarations: [
    		RegistrationComponent,
    		LoginComponent
    	],
    	entryComponents: [
    		LoginComponent,
    		RegistrationComponent
    	],
    	providers: [
    		AccountService,
    		MatDialog,
    		MatDialogRef
    	]
    })
    export class AccountModule {}

&lt;!-- end snippet --&gt;

home.component.ts

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    import { Component } from &#39;@angular/core&#39;;

    import { MatDialog } from &#39;@angular/material&#39;;
    import { RegistrationComponent } from &#39;../account/components/registration.component&#39;;

    @Component({
        moduleId: module.id.replace(&#39;compiled&#39;, &#39;app&#39;),
        templateUrl: &#39;home.component.html&#39;
    })
    export class HomeComponent
    {
        constructor(private modalService: MatDialog) {}

        public openModal() : void
        {
            let dialog = this.modalService.open(RegistrationComponent, {});
        }
    }

&lt;!-- end snippet --&gt;

registration.component.ts

&lt;!-- begin snippet: js hide: false console: true babel: false --&gt;

&lt;!-- language: lang-js --&gt;

    import { Component } from &#39;@angular/core&#39;;
    import { Router } from &#39;@angular/router&#39;;
    import { MatDialogRef } from &#39;@angular/material/dialog&#39;;

    import { User } from &#39;../../../models/domain/User&#39;;
    import { ApiUserService } from &#39;../../api/entity-services/user.service&#39;;
    import { AuthService } from &#39;../../auth/auth.service&#39;;
    import { AccountService } from &#39;../services/account.service&#39;

    @Component({
    	selector: &#39;registration-component&#39;,
    	templateUrl: &#39;app/modules/account/templates/registration.component.html&#39;
    })
    export class RegistrationComponent
    {
    	public user :User = new User();

    	public errorMessage :string;

    	public isLoading :boolean;

    	constructor
    	(
    		private userService :ApiUserService,
    		private authService :AuthService,
    		private accountService :AccountService,
    		private router :Router,
    		public dialogRef :MatDialogRef&lt;RegistrationComponent&gt;
    	)
    	{
    		this.isLoading = false;
    	}

    	public onSubmit(e) :void
    	{
    		e.preventDefault();
    		this.isLoading = true;

    		this.userService
    			.Create(this.user)
    			.subscribe(
    				user =&gt;
    				{
    					this.user.id = user.id;
    					this.user.login = user.login;


    					this.authService
    						.Login(this.user)
    						.subscribe(
    							token =&gt;
    							{
    								this.accountService.Load()
    									.subscribe(
    										account =&gt;
    										{
    											this.user = account;
    											this.isLoading = false;
    											this.dialogRef.close();

    											let redirectRoute = account.activeScopeId
    												? `/scope/${account.activeScopeId}`
    												: &#39;/scope-list/&#39;;

    											this.router.navigate([redirectRoute]);
    										},
    										error =&gt; this.errorMessage = &lt;any&gt;error
    									);
    							},
    							error =&gt; this.errorMessage = &lt;any&gt;error
    						);
    				},
    				error =&gt; this.errorMessage = &lt;any&gt;error
    			);
    	}
    }

&lt;!-- end snippet --&gt;



NullInjectorError: No provider for MatDialogRef

Classification problems, such as logistic regression or multinomial
logistic regression, optimize a **cross-entropy** loss.
Normally, the cross-entropy layer follows the **softmax** layer,
which produces probability distribution.

In tensorflow, there are at least a **dozen of different cross-entropy loss functions**:

- `tf.losses.softmax_cross_entropy`
- `tf.losses.sparse_softmax_cross_entropy`
- `tf.losses.sigmoid_cross_entropy`
- `tf.contrib.losses.softmax_cross_entropy`
- `tf.contrib.losses.sigmoid_cross_entropy`
- `tf.nn.softmax_cross_entropy_with_logits`
- `tf.nn.sigmoid_cross_entropy_with_logits`
- ...

Which one works only for binary classification and which are suitable for multi-class problems? When should you use `sigmoid` instead of `softmax`? How are `sparse` functions different from others and why is it only `softmax`?

Related (more math-oriented) discussion: https://stackoverflow.com/q/44674847/712995. 


How to choose cross-entropy loss in TensorFlow?

I was snooping through my MSP430 microcontroller&#39;s header files, and I ran into this in `&lt;setjmp.h&gt;`:

    /* r3 does not have to be saved */
    typedef struct
    {
    	uint32_t __j_pc; /* return address */
    	uint32_t __j_sp; /* r1 stack pointer */
    	uint32_t __j_sr; /* r2 status register */
    	uint32_t __j_r4;
    	uint32_t __j_r5;
    	uint32_t __j_r6;
    	uint32_t __j_r7;
    	uint32_t __j_r8;
    	uint32_t __j_r9;
    	uint32_t __j_r10;
    	uint32_t __j_r11;
    } jmp_buf[1]; /* size = 20 bytes */

I understand that it declares an anonymous struct and typedef&#39;s it to `jmp_buf`, but I can&#39;t figure out what the `[1]` is for. I know it declares `jmp_buf` to be an array with one member (of this anonymous struct), but I can&#39;t imagine what it&#39;s used for. Any ideas?

What&#39;s the purpose of this [1] at the end of struct declaration?

I was snooping through my MSP430 microcontroller's header files, and I ran into this in <code>&#x3C;setjmp.h></code>:
<pre><code class="hljs language-arduino">/* r3 does not have to be saved */
typedef struct
{
	uint32_t __j_pc; /* return address */
	uint32_t __j_sp; /* r1 stack pointer */
	uint32_t __j_sr; /* r2 status register */
	uint32_t __j_r4;
	uint32_t __j_r5;
	uint32_t __j_r6;
	uint32_t __j_r7;
	uint32_t __j_r8;
	uint32_t __j_r9;
	uint32_t __j_r10;
	uint32_t __j_r11;
} jmp_buf[1]; /* size = 20 bytes */
</code></pre>
I understand that it declares an anonymous struct and typedef's it to <code>jmp_buf</code>, but I can't figure out what the <code>[1]</code> is for. I know it declares <code>jmp_buf</code> to be an array with one member (of this anonymous struct), but I can't imagine what it's used for. Any ideas?

As an example, consider the following structure:

    struct S {
      int a[4];
      int b[4];
    } s;

Would it be legal to write `s.a[6]` and expect it to be equal to `s.b[2]`?
Personally, I feel that it must be UB in C++, whereas I&#39;m not sure about C.
However, I failed to find anything relevant in the standards of C and C++ languages.


---
**Update**

There are several answers suggesting ways to make sure there is no padding
between fields in order to make the code work reliably. I&#39;d like to emphasize
that if such code is UB, then absense of padding is not enough. If it is UB,
then the compiler is free to assume that accesses to `S.a[i]` and `S.b[j]` do not
overlap and the compiler is free to reorder such memory accesses. For example,

        int x = s.b[2];
        s.a[6] = 2;
        return x;

can be transformed to

        s.a[6] = 2;
        int x = s.b[2];
        return x;

which always returns `2`.


In a structure, is it legal to use one array field to access another one?

As I was checking news about GCC 8, I [saw](https://www.phoronix.com/scan.php?page=news_item&amp;px=GCC-C17-Support-Coming) that they added support for the 2017 version of the C language (not C++17, really C17). But I can&#39;t find any information about it on Internet.

**Is it a new ISO version like C11, or just a codename used by the GCC team for some corrections in their compiler ?**

What is C17 and what changes have been made to the language?

When I work on my personal C and C++ projects I usually put `file.h` and `file.cpp` in the same directory and then `file.cpp` can reference `file.h` with a `#include &quot;file.h&quot;` directive.

However, it is common to find out libraries and other kinds of projects (like the linux kernel and freeRTOS) where all `.h` files are placed inside an `include/` directory, while `.cpp` files remain in another directory. In those projects, `.h` files are also included with `#include &quot;file.h&quot;` instead of `#include &quot;include/file.h&quot;` as I was hoping.

I have some questions about all of this:

 1. What are the advantages of this file structure organization?
 2. Why are `.h` files inside `include/` included with `#include &quot;file.h&quot;` instead of `#include &quot;include/file.h&quot;`? I know the real trick is inside some Makefile, but is it really better to do that way instead of making clear (in code) that the file we want to include is actually in the `include/` directory?



Why create an include/ directory in C and C++ projects?

In C/C++, why should one use `abs()` or `fabs()` to find the absolute value of a variable without using the following code?

    int absoluteValue = value &lt; 0 ? -value : value;

Does it have something to do with fewer instructions at lower level?

Why use abs() or fabs() instead of conditional negation?

Could someone give me an explanation why I get two different 
numbers, resp. 14 and 15, as an output from the following code?

    #include &lt;stdio.h&gt;  

    int main()
    {
        double Vmax = 2.9; 
        double Vmin = 1.4; 
        double step = 0.1; 

        double a =(Vmax-Vmin)/step;
        int b = (Vmax-Vmin)/step;
        int c = a;

        printf(&quot;%d  %d&quot;,b,c);  // 14 15, why?
        return 0;
    }

I expect to get 15 in both cases but it seems I&#39;m missing some fundamentals of the language.

I am not sure if it&#39;s relevant but I was doing the test in CodeBlocks. However, if I type the same lines of code in some on-line compiler ( [this one for example][1]) I get an answer of 15 for the two printed variables.


  [1]: https://www.onlinegdb.com/online_c_compiler

Nonintuitive result of the assignment of a double precision number to an int variable in C

What does C++ syntax `struct A::B:A {};` mean? Where is this name definition (or access) described in the C++ standard?

    #include &lt;iostream&gt;
    
    struct B;
    
    struct A {
        struct B;
    };
    
    struct A::B:A {
    };
    
    int main() {
        A::B::A::B b;
        std::cout&lt;&lt;&quot;Sizeof A::B::A::B is &quot; &lt;&lt; sizeof(A::B::A::B)&lt;&lt;std::endl;
        return 0;
    }

What does C++ syntax “A::B:A {};” mean

Does initializing a member variable and not referencing/using it further take up RAM during runtime, or does the compiler simply ignore that variable?

    struct Foo {
        int var1;
        int var2;

        Foo() { var1 = 5; std::cout &lt;&lt; var1; }
    };

In the example above, the member &#39;var1&#39; gets a value which is then displayed in the console. &#39;Var2&#39;, however, is not used at all. Therefore writing it to memory during runtime would be a waste of resources. Does the compiler take these kinds of situations into an account and simply ignore unused variables, or is the Foo object always the same size, regardless of whether its members are used?


Does an unused member variable take up memory?

I hit some [tag:c] [code](https://elixir.bootlin.com/linux/v4.4.161/source/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c#L246) in Linux kernel:

    static struct ctl_table ip_ct_sysctl_table[] = {
    	{
    		.procname	= &quot;ip_conntrack_max&quot;,
    		.maxlen		= sizeof(int),
    		.mode		= 0644,
    		.proc_handler	= proc_dointvec,
    	},
        // ...
    	{
    		.procname	= &quot;ip_conntrack_log_invalid&quot;,
    		.maxlen		= sizeof(unsigned int),
    		.mode		= 0644,
    		.proc_handler	= proc_dointvec_minmax,
    		.extra1		= &amp;log_invalid_proto_min,
    		.extra2		= &amp;log_invalid_proto_max,
    	},
    	{ }
    };

Here an array of structs ends with `{ }`. For what purpose was it added?  
By the way, a bit above this code there is another [array of structs](https://elixir.bootlin.com/linux/v4.4.161/source/net/ipv4/netfilter/nf_conntrack_l3proto_ipv4.c#L170), but without empty braces at the end.

When should I use empty braces at the end of an array of structs?

What is the need of empty braces &#39;{ }&#39; at the end of array of structs?

I just recently took an intermediate programming test, and one of the questions I got wrong was as follows:

&gt; A semicolon (&#39;;&#39;) is not needed after a function declaration.
&gt;
&gt; True or False.

I chose &quot;false&quot; (and please correct me if I&#39;m wrong because I feel like I&#39;m going crazy), a function **declaration** is what you write before the definition (at the top of the code) so the compiler knows the function call before even calling it, and a function **definition** is what makes up the function as a whole.

I.e.,

**Declaration:**

    int func();

**Definition:**

    int func() {
      return 1;
    }

Shouldn&#39;t the answer to this be false?


Isn&#39;t a semicolon (&#39;;&#39;) needed after a function declaration in C++?

I&#39;m certainly missing something, but I do not understand why this compiles (with both g++ &amp; clang++):

    struct A
    {
    };
    struct B
    {
    };

    int main()
    {
      A a(B);
    }

First of all, `B` is a type... not a value. How should I interpret this code?




Content Type	Original Author	Original Content on Stackoverflow
Question	Alexander	View Question on Stackoverflow
Solution 1 - C	ShadowRanger	View Answer on Stackoverflow

What's the purpose of this [1] at the end of struct declaration?

C Problem Overview

C Solutions

Solution 1 - C

How to choose cross-entropy loss in TensorFlow?

NullInjectorError: No provider for MatDialogRef

Attributions