Re: CWinThread Termination - C / C++ / MFC Discussion Boards

Re: Sum Multiple Value At a Time

Mr. Anup Roy31-Aug-17 5:25

Mr. Anup Roy

31-Aug-17 5:25

Variable number of input..

Re: Sum Multiple Value At a Time

jeron131-Aug-17 6:38

jeron1

31-Aug-17 6:38

In keeping with Davids theme, you could specify an array that's larger than you would ever need, and have the user enter the number of entries first, then setup an input loop based on that. Or setup a loop that runs the same number of times as your array size and have the user enter a value (like -1) that denotes the end of the data at which point you would exit the loop, then process the the data entered prior to the -1 entry.

"the debugger doesn't tell me anything because this code compiles just fine" - random QA comment
"Facebook is where you tell lies to your friends. Twitter is where you tell the truth to strangers." - chriselst
"I don't drink any more... then again, I don't drink any less." - Mike Mullikins uncle

Re: Sum Multiple Value At a Time

David Crow30-Aug-17 11:31

David Crow

30-Aug-17 11:31

You'd need to use an array and a loop. Something like:

int hours[5] = {0};
for (int x = 0; x < 5; x++)
{
    cout << "Enter hours worked for day " << (x + 1) << ": ";
    cin >> hours[x];
}

"One man's wage rise is another man's price increase." - Harold Wilson

"Fireproof doesn't mean the fire will never come. It means when the fire comes that you will be able to withstand it." - Michael Simmons

"You can easily judge the character of a man by how he treats those who can do nothing for him." - James D. Miles

Re: Sum Multiple Value At a Time

Mr. Anup Roy31-Aug-17 5:27

Mr. Anup Roy

31-Aug-17 5:27

Hi David,
I got it thanks for your help.

CWinThread Termination

Lakshminaryana A29-Aug-17 19:38

Lakshminaryana A

29-Aug-17 19:38

How to Terminate a thread created from CWinThread, without checking flag in thread function or ::TerminateThread (WinAPI)?

Example:

CWinThread* Obj;
Obj = AfxBeginThread(ThreadProc, this);

UINT ThreadProc(LPVOID *pVoid)
{
while(1)
{
//do something
}

return 0;
}

Now I want to terminate the ThreadProc without using flag or TeminateThread?

Thanks in Adavance Smile | :)

modified 30-Aug-17 5:18am.

Re: CWinThread Termination

Richard MacCutchan29-Aug-17 22:02

Richard MacCutchan

29-Aug-17 22:02

Why not just use the features that are available?

Re: CWinThread Termination

Jochen Arndt29-Aug-17 22:27

Jochen Arndt

29-Aug-17 22:27

Just exit the thread function using a return statement (which is missing but required in your example code).

After adding the missing return statement, you may then also break out of the endless while loop.

Re: CWinThread Termination

Lakshminaryana A30-Aug-17 0:17

Lakshminaryana A

30-Aug-17 0:17

Thank you for your response

I want to terminate the ThreadProc from outside of the thread

Re: CWinThread Termination

Jochen Arndt30-Aug-17 0:33

Jochen Arndt

30-Aug-17 0:33

That was not really clear.

Then you have to signal the thread that it should terminate. If you don't want to use a global flag, use some kind of event. To check for events use WaitForSingleObject or WaitForMultipleObject (when multiple events must be handled).

Examples can be found in any MFC thread tutorial.

An old but very good article is:
Using Worker Threads[^] (see the Thread Shutdown Without Polling section).
Also available at WorkerThreads[^].

Re: CWinThread Termination

Victor Nijegorodov30-Aug-17 6:54

Victor Nijegorodov

30-Aug-17 6:54

Member 13147508 wrote:
How to Terminate a thread created from CWinThread, without checking flag in thread function or ::TerminateThread (WinAPI)?

Example:

CWinThread* Obj;
Obj = AfxBeginThread(ThreadProc, this);

UINT ThreadProc(LPVOID *pVoid)
{
while(1)
{
//do something
}

return 0;
}

The cleanest way to exit the thread is to return from the thread procedure.
And it is exactlz what your ThreadProc does!
So, nothing more!

Re: CWinThread Termination

David Crow30-Aug-17 11:27

David Crow

30-Aug-17 11:27

See the OP's response here.

C: warning: excess elements in array initializer

Member 1326117527-Aug-17 23:27

Member 13261175

27-Aug-17 23:27

I've some warnings while trying to compile program in C language

#include <stdio.h>


int codecheck(int col,int col_p,int rows_p,int **H,int x[])
{	int i,j,m,f; //flags
	int sum = 0;
	int y[col];

	for (i=0;i<col;i++)
	y[i]=0;
	m=1;
	f=-1;
	for(i=0;i<rows_p;)
	{
		for(j=0;j<rows_p;j++)
		{
			if(H[j][0]==m)
			{
				y[m]=y[m] + x[H[j][1]-1];
					f++;
			}
		}
		y[m]=y[m]%2;
		m=m+1;
		
		i=f+1;
	}

	for (i = 0; i < col; ++i)
		{
			sum =sum+ y[i];
		}
	if (sum == 0)
		{
			return 1;
		}
	else
		{
			return -1;
		}

}

int codesum (int y[],int col)
{
    int sum=0;
    for(int i=0;i<col;i++)
        sum+=y[i];
    
    if(sum>0)
        return 0;
    else
        return 1;
}

void ModulationSchemeValues (int &modulationScheme, int &noOfSymbols, double &var, float &d, int &col, float &rate, double &snr)
{
	            switch (modulationScheme)
            {
                case 0:
                    var=1/(2*rate*snr);
                    noOfSymbols = col;
                    d=1;
                    break;
                case 1:
                    var=1/(4*rate*snr);
                    noOfSymbols = col/2;
                    d=1/sqrt(2);
                    break;
                case 2:
                    var=1/(8*rate*snr);
                    noOfSymbols = col/4;
                    d=1/sqrt(10);
                default:
                    var=1/(2*rate*snr);
                    noOfSymbols = col;
                    d=1;
                    break;
            }
}

void InitializeChannelLLR (double &var, int &modulationScheme, int &noOfSymbols, float x[], double noise[], double L_ch[], float &d, int &rows_p, vector<vector <int>> &h, double LLR[])
{
   
    int j=0;   
   int k=0,t;
    for(int i=0;i<noOfSymbols;i++)						
    {
        if(modulationScheme==0)
        {
            x[j]=d;
            noise[j]=(x[j])+0.5;
            L_ch[j]= 2*noise[j]/var;
            j++;
        }
        else if(modulationScheme==1)
        {
            x[j] = d;
            j++;
            x[j] = d;
            j++;
            noise[j-2]=(x[j-2])+dist(generator);
            L_ch[j-2]= 2*noise[j-2]/var;
            noise[j-1]=(x[j-1])+dist(generator);
            L_ch[j-1]= 2*noise[j-1]/var;
        }
        else if(modulationScheme==2)
        {

            x[j] = 3*d;                                
            noise[j] = (x[j]) + dist(generator);
            j++;
            x[j] = 3*d;                                 
            noise[j] = (x[j]) + dist(generator);
            j++;


            if(noise[j-2] >= (2*d))
                L_ch[k] = (8*noise[j-2]*d/(2*var)) - (8*pow(d,2)/(2*var));
            else if(noise[j-2] >= -2*d && noise[j-2] <= 2*d)
                L_ch[k] = 4*noise[j-2]*d/(2*var);
            else if(noise[j-2] <= -2*d)
                L_ch[k] = (8*noise[j-2]*d/(2*var)) + (8*pow(d,2)/(2*var));
            k++;

            if(noise[j-1] >= (2*d))
                L_ch[k] = (8*noise[j-1]*d/(2*var)) - (8*pow(d,2)/(2*var));
            else if(noise[j-1] >= -2*d && noise[j-1] <= 2*d)
                L_ch[k] = 4*noise[j-1]*d/(2*var);
            else if(noise[j-1] <=- 2*d)
                L_ch[k] = (8*noise[j-1]*d/(2*var)) + (8*pow(d,2)/(2*var));
            k++;

            if(noise[j-2] >= 0)
                L_ch[k] = (-8*pow(d,2)/(2*var)) + (4*noise[j-2]*d/(2*var));
            else
                L_ch[k] = (-8*pow(d,2)/(2*var)) - (4*noise[j-2]*d/(2*var));
            k++;

            if(noise[j-1] >= 0)
                L_ch[k] = (-8*pow(d,2)/(2*var)) + (4*noise[j-1]*d/(2*var));
            else
                L_ch[k] = (-8*pow(d,2)/(2*var)) - (4*noise[j-1]*d/(2*var));
            k++;
        }

    }

    for(int j=0;j<rows_p;j++)
    {
        
        t=h[j][1]-1;
        LLR[j]=L_ch[t];
    }
 
}


void SPADecoder(int &rows_p, double LLR[], vector<vector <int>> &h, double LLR_ret[], double L_ch[],  double L_dec[], int y[], int &z, int &col)
{
    double temp;
    int i,j,k;
    for(i=0;i<rows_p;i++)
    {
        temp=1;
        for(j=0;j<rows_p;j++)
        {
            if(j!=i && h[j][0]==h[i][0])
            {
                temp=temp * tanhf(LLR[j]/2);
            }
        }


        LLR_ret[i] = log((1 + temp)/(1 - temp));     

        if(LLR_ret[i] > 40)
        {
            LLR_ret[i]=40;
        }
        else if(LLR_ret[i]<-40)
        {
            LLR_ret[i]=-40;
        }

    }

    for(i=0;i<col;i++)							
    {
        L_dec[i]=L_ch[i];
    }


    for(i=1;i<col+1;i++)						
    {
        for(j=0;j<rows_p;j++)
        {
            if(h[j][1]==i)
            {
                L_dec[i-1]=L_dec[i-1]+LLR_ret[j];
            }

        }

        if(L_dec[i-1]<=0)					
        {
            y[i-1]=1;
        }
        else
        {
            y[i-1]=0;
        }

    }


    //z = codesum(y,col);
    z=codecheck(col, col_p,rows_p,h,y); 

    if(z==1)								
    {
        return ;
    }
 
    for(i=0;i<rows_p;i++)
    {
        temp=0;
        for(j=0;j<rows_p;j++)
        {
            if(j!=i && h[j][1]==h[i][1])
            {
                temp=temp + LLR_ret[j];
                k=h[i][1];

            }
        }
        LLR[i] = temp+L_ch[k-1];
    }

}

int main()
{


	// flags and counters
	int z,i,j,N,k,ber_count,looping,t,sum;
    float d=1;
	float rate=0.5;
	int rows_p,col_p=2;
	int col,maxTransmissions=4000,decoderIterations=20,maxErrors=100,errorsAccumulated=0;			

    rows_p=1020;
    col=204;


	double var,snr;
	double temp; 								

    float y[col],noise[col];  
    double L_ch[col],L_dec[col];    
	double LLR[rows_p],LLR_ret[rows_p];					
	double BER[11];												
    float snr_db[]={0,1,2,3,4};
    int snr_range=5,snr_count;
    int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
    int  ret,row=0;
	double error_bits,error;
    
    int modulationScheme = 0,noOfSymbols;
	int h[rows_p][col_p]={1,1,1,18,1,27,1,82,1,102,1,103,1,130,1,177,1,190,1,203,2,2,2,15,2,75,2,80,2,86,2,104,2,121,2,141,2,144,2,191,3,3,3,31,3,32,3,42,3,101,3,105,3,153,3,159,3,178,3,199,4,4,4,37,4,71,4,75,4,85,4,106,4,111,4,114,4,127,4,164,5,5,5,17,5,42,5,72,5,87,5,107,5,141,5,158,5,193,5,197,6,4,6,6,6,17,6,78,6,102,6,108,6,162,6,165,6,167,6,174,7,7,7,23,7,73,7,80,7,83,7,109,7,118,7,168,7,177,7,178,8,8,8,33,8,37,8,73,8,100,8,110,8,156,8,173,8,192,8,197,9,9,9,40,9,41,9,88,9,92,9,103,9,111,9,173,9,181,9,199,10,10,10,14,10,23,10,53,10,93,10,107,10,112,10,137,10,167,10,175,11,11,11,19,11,26,11,28,11,88,11,110,11,113,11,116,11,170,11,191,12,1,12,12,12,25,12,86,12,97,12,108,12,114,12,124,12,161,12,192,13,4,13,13,13,33,13,34,13,50,13,115,13,137,13,140,13,146,13,160,14,14,14,31,14,40,14,58,14,95,14,116,14,121,14,166,14,174,14,203,15,15,15,68,15,70,15,87,15,101,15,109,15,113,15,117,15,165,15,180,16,4,16,16,16,59,16,67,16,92,16,118,16,125,16,131,16,138,16,151,17,15,17,17,17,44,17,71,17,73,17,119,17,161,17,190,17,194,17,198,18,18,18,47,18,62,18,85,18,93,18,120,18,122,18,125,18,146,18,181,19,19,19,22,19,23,19,37,19,57,19,121,19,126,19,130,19,131,19,143,20,1,20,20,20,50,20,51,20,99,20,106,20,122,20,169,20,179,20,200,21,21,21,32,21,62,21,72,21,98,21,123,21,126,21,154,21,168,21,204,22,22,22,31,22,44,22,89,22,98,22,124,22,141,22,160,22,169,22,176,23,23,23,32,23,61,23,65,23,99,23,125,23,132,23,133,23,147,23,152,24,16,24,24,24,42,24,73,24,77,24,126,24,142,24,145,24,146,24,147,25,5,25,24,25,25,25,55,25,67,25,127,25,133,25,165,25,178,25,185,26,10,26,26,26,27,26,40,26,85,26,128,26,147,26,155,26,160,26,200,27,22,27,27,27,42,27,50,27,74,27,108,27,129,27,154,27,170,27,195,28,2,28,28,28,63,28,67,28,94,28,130,28,150,28,171,28,187,28,192,29,29,29,48,29,69,29,79,29,90,29,116,29,131,29,159,29,176,29,200,30,7,30,30,30,53,30,58,30,94,30,127,30,132,30,140,30,162,30,189,31,29,31,31,31,64,31,77,31,94,31,117,31,133,31,167,31,183,31,190,32,20,32,30,32,32,32,74,32,78,32,115,32,134,32,151,32,181,32,194,33,11,33,33,33,47,33,76,33,81,33,109,33,135,33,154,33,155,33,179,34,2,34,7,34,34,34,71,34,76,34,136,34,138,34,159,34,182,34,183,35,27,35,29,35,35,35,60,35,86,35,123,35,137,35,149,35,166,35,189,36,17,36,35,36,36,36,48,36,100,36,138,36,139,36,146,36,163,36,168,37,5,37,34,37,37,37,38,37,69,37,117,37,139,37,145,37,169,37,203,38,38,38,56,38,76,38,92,38,101,38,106,38,123,38,140,38,161,38,170,39,39,39,41,39,60,39,76,39,78,39,125,39,141,39,142,39,175,39,198,40,2,40,35,40,40,40,43,40,93,40,114,40,135,40,142,40,148,40,158,41,1,41,2,41,13,41,41,41,59,41,109,41,119,41,132,41,143,41,157,42,11,42,42,42,43,42,92,42,95,42,115,42,117,42,144,42,156,42,204,43,7,43,9,43,43,43,45,43,56,43,122,43,145,43,192,43,194,43,201,44,10,44,44,44,75,44,83,44,95,44,110,44,135,44,146,44,157,44,180,45,45,45,63,45,79,45,81,45,97,45,127,45,139,45,147,45,148,45,195,46,34,46,46,46,61,46,66,46,77,46,105,46,144,46,148,46,197,46,201,47,14,47,20,47,46,47,47,47,83,47,124,47,128,47,132,47,149,47,159,48,8,48,13,48,26,48,48,48,62,48,149,48,150,48,174,48,193,48,195,49,15,49,21,49,25,49,49,49,51,49,145,49,149,49,151,49,177,49,188,50,8,50,49,50,50,50,54,50,89,50,105,50,126,50,152,50,164,50,165,51,43,51,51,51,66,51,68,51,91,51,131,51,133,51,153,51,187,51,189,52,1,52,39,52,45,52,52,52,54,52,110,52,140,52,150,52,154,52,163,53,8,53,53,53,60,53,64,53,90,53,138,53,155,53,157,53,194,53,204,54,12,54,28,54,54,54,60,54,82,54,112,54,139,54,151,54,156,54,183,55,3,55,17,55,37,55,55,55,99,55,112,55,148,55,157,55,172,55,189,56,20,56,31,56,56,56,80,56,91,56,152,56,156,56,158,56,162,56,180,57,28,57,57,57,66,57,81,57,89,57,134,57,137,57,159,57,172,57,196,58,5,58,58,58,70,58,78,58,91,58,118,58,149,58,154,58,160,58,201,59,18,59,24,59,59,59,88,59,96,59,150,59,152,59,161,59,179,59,183,60,21,60,38,60,55,60,59,60,60,60,162,60,176,60,187,60,190,60,197,61,61,61,69,61,74,61,93,61,101,61,111,61,128,61,163,61,193,61,196,62,6,62,7,62,35,62,62,62,96,62,103,62,113,62,129,62,164,62,200,63,16,63,27,63,44,63,63,63,88,63,121,63,134,63,165,63,175,63,188,64,4,64,26,64,64,64,79,64,84,64,119,64,134,64,136,64,166,64,168,65,12,65,13,65,52,65,57,65,65,65,106,65,138,65,142,65,167,65,176,66,24,66,30,66,52,66,66,66,102,66,112,66,117,66,122,66,135,66,168,67,6,67,57,67,67,67,85,67,97,67,140,67,169,67,182,67,184,67,186,68,6,68,58,68,68,68,71,68,90,68,134,68,143,68,145,68,152,68,170,69,54,69,57,69,59,69,69,69,77,69,103,69,104,69,114,69,136,69,171,70,19,70,24,70,56,70,70,70,100,70,105,70,114,70,128,70,129,70,172,71,14,71,52,71,63,71,70,71,71,71,120,71,169,71,173,71,178,71,196,72,11,72,25,72,39,72,66,72,72,72,120,72,130,72,132,72,174,72,199,73,48,73,49,73,64,73,73,73,98,73,111,73,175,73,179,73,201,73,202,74,9,74,15,74,58,74,74,74,84,74,107,74,120,74,135,74,164,74,176,75,28,75,41,75,70,75,75,75,96,75,133,75,155,75,166,75,177,75,202,76,26,76,45,76,65,76,76,76,94,76,144,76,158,76,172,76,178,76,203,77,10,77,13,77,77,77,84,77,87,77,127,77,151,77,163,77,179,77,191,78,49,78,55,78,65,78,78,78,90,78,122,78,130,78,139,78,180,78,182,79,33,79,43,79,67,79,79,79,99,79,123,79,141,79,181,79,188,79,202,80,18,80,19,80,35,80,46,80,80,80,153,80,167,80,182,80,188,80,193,81,9,81,16,81,36,81,55,81,81,81,143,81,160,81,183,81,186,81,191,82,10,82,11,82,79,82,82,82,96,82,108,82,111,82,126,82,172,82,184,83,12,83,36,83,69,83,83,83,87,83,148,83,174,83,185,83,202,83,204,84,45,84,47,84,48,84,75,84,84,84,108,84,123,84,142,84,153,84,186,85,9,85,46,85,53,85,54,85,85,85,115,85,121,85,129,85,177,85,187,86,22,86,64,86,83,86,86,86,91,86,107,86,116,86,171,86,188,86,199,87,8,87,22,87,61,87,81,87,87,87,104,87,120,87,182,87,189,87,198,88,32,88,33,88,39,88,51,88,88,88,129,88,143,88,171,88,180,88,190,89,3,89,21,89,52,89,89,89,100,89,103,89,109,89,115,89,125,89,191,90,20,90,40,90,44,90,61,90,90,90,118,90,137,90,153,90,184,90,192,91,6,91,23,91,29,91,84,91,91,91,144,91,155,91,173,91,185,91,193,92,14,92,49,92,72,92,92,92,102,92,147,92,171,92,185,92,186,92,194,93,5,93,21,93,29,93,65,93,93,93,105,93,110,93,119,93,184,93,195,94,39,94,80,94,82,94,94,94,98,94,107,94,113,94,131,94,166,94,196,95,30,95,47,95,50,95,63,95,95,95,104,95,118,95,161,95,163,95,197,96,25,96,34,96,56,96,68,96,96,96,116,96,181,96,186,96,196,96,198,97,36,97,38,97,46,97,89,97,97,97,113,97,136,97,150,97,157,97,199,98,3,98,12,98,18,98,30,98,98,98,136,98,170,98,187,98,198,98,200,99,53,99,62,99,74,99,97,99,99,99,104,99,119,99,156,99,185,99,201,100,16,100,68,100,82,100,95,100,100,100,106,100,124,100,158,100,195,100,202,101,19,101,36,101,41,101,72,101,101,101,112,101,124,101,162,101,164,101,203,102,3,102,38,102,51,102,86,102,102,102,128,102,173,102,175,102,184,102,204};,


	for(snr_count=0;snr_count<snr_range;snr_count++)
	{
       
				snr=pow(10,(snr_db[snr_count]/10));

				ModulationSchemeValues (modulationScheme, noOfSymbols, var, d, col, rate, snr);  // determining various values based on mdulation scheme

        							
				BER[snr_count]=0;								
          
                N=0;
                errorsAccumulated=0;
					while(errorsAccumulated<=maxErrors && N<=maxTransmissions)
					{
                        N++;

                        InitializeChannelLLR( var, modulationScheme, noOfSymbols, x, noise,  L_ch, d, rows_p, h, LLR);

                        for(looping=0;looping<decoderIterations;looping++)
						{

                            SPADecoder(rows_p, LLR, h, LLR_ret, L_ch, L_dec, y, z, col  );

						}

							if(z==1)											
								{
									BER[snr_count]=BER[snr_count]+0;

								}
							else 												
								{
									error_bits=0;
									for(i=0;i<col;i++)
									{
										if(y[i]!=0)
										{
											error_bits++;

										}
									}
                                    errorsAccumulated+=error_bits;
                                    error=error_bits/(double)col;
									BER[snr_count]=BER[snr_count]+error;
								}
                        if(N%300==0)
                        
					}

					BER[snr_count]=BER[snr_count]/(double)N; 					
					printf("snr=%lf\tBER[%d]=%lf \n",snr_db[snr_count],snr_count,BER[snr_count]);
	}

return 0;


}

WARNING MESSAGE

rog.c:60:34: error: expected ';', ',' or ')' before '&' token
 void ModulationSchemeValues (int &modulationScheme, int &noOfSymbols, double &var, float &d, int &col, float &rate, double &snr)
                                  ^
prog.c:89:35: error: expected ';', ',' or ')' before '&' token
 void InitializeChannelLLR (double &var, int &modulationScheme, int &noOfSymbols, float x[], double noise[], double L_ch[], float &d, int &rows_p, vector<vector <int>> &h, double LLR[])
                                   ^
prog.c:173:21: error: expected ';', ',' or ')' before '&' token
 void SPADecoder(int &rows_p, double LLR[], vector<vector <int>> &h, double LLR_ret[], double L_ch[],  double L_dec[], int y[], int &z, int &col)
                     ^
prog.c: In function 'main':
prog.c:281:5: error: variable-sized object may not be initialized
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
     ^
prog.c:281:17: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                 ^
prog.c:281:17: note: (near initialization for 'x')
prog.c:281:19: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                   ^
prog.c:281:19: note: (near initialization for 'x')
prog.c:281:21: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                     ^
prog.c:281:21: note: (near initialization for 'x')
prog.c:281:23: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                       ^
prog.c:281:23: note: (near initialization for 'x')
prog.c:281:25: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                         ^
prog.c:281:25: note: (near initialization for 'x')
prog.c:281:27: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                           ^
prog.c:281:27: note: (near initialization for 'x')
prog.c:281:29: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                             ^
prog.c:281:29: note: (near initialization for 'x')
prog.c:281:31: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                               ^
prog.c:281:31: note: (near initialization for 'x')
prog.c:281:33: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                 ^
prog.c:281:33: note: (near initialization for 'x')
prog.c:281:35: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                   ^
prog.c:281:35: note: (near initialization for 'x')
prog.c:281:37: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                     ^
prog.c:281:37: note: (near initialization for 'x')
prog.c:281:39: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                       ^
prog.c:281:39: note: (near initialization for 'x')
prog.c:281:41: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                         ^
prog.c:281:41: note: (near initialization for 'x')
prog.c:281:43: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                           ^
prog.c:281:43: note: (near initialization for 'x')
prog.c:281:45: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                             ^
prog.c:281:45: note: (near initialization for 'x')
prog.c:281:47: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                               ^
prog.c:281:47: note: (near initialization for 'x')
prog.c:281:49: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                 ^
prog.c:281:49: note: (near initialization for 'x')
prog.c:281:51: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                   ^
prog.c:281:51: note: (near initialization for 'x')
prog.c:281:53: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                     ^
prog.c:281:53: note: (near initialization for 'x')
prog.c:281:55: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                       ^
prog.c:281:55: note: (near initialization for 'x')
prog.c:281:57: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                         ^
prog.c:281:57: note: (near initialization for 'x')
prog.c:281:59: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                           ^
prog.c:281:59: note: (near initialization for 'x')
prog.c:281:61: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                             ^
prog.c:281:61: note: (near initialization for 'x')
prog.c:281:63: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                               ^
prog.c:281:63: note: (near initialization for 'x')
prog.c:281:65: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                 ^
prog.c:281:65: note: (near initialization for 'x')
prog.c:281:67: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                   ^
prog.c:281:67: note: (near initialization for 'x')
prog.c:281:69: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                     ^
prog.c:281:69: note: (near initialization for 'x')
prog.c:281:71: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                       ^
prog.c:281:71: note: (near initialization for 'x')
prog.c:281:73: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                         ^
prog.c:281:73: note: (near initialization for 'x')
prog.c:281:75: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                           ^
prog.c:281:75: note: (near initialization for 'x')
prog.c:281:77: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                             ^
prog.c:281:77: note: (near initialization for 'x')
prog.c:281:79: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                               ^
prog.c:281:79: note: (near initialization for 'x')
prog.c:281:81: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                 ^
prog.c:281:81: note: (near initialization for 'x')
prog.c:281:83: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                   ^
prog.c:281:83: note: (near initialization for 'x')
prog.c:281:85: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                     ^
prog.c:281:85: note: (near initialization for 'x')
prog.c:281:87: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                       ^
prog.c:281:87: note: (near initialization for 'x')
prog.c:281:89: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                         ^
prog.c:281:89: note: (near initialization for 'x')
prog.c:281:91: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                           ^
prog.c:281:91: note: (near initialization for 'x')
prog.c:281:93: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                             ^
prog.c:281:93: note: (near initialization for 'x')
prog.c:281:95: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                               ^
prog.c:281:95: note: (near initialization for 'x')
prog.c:281:97: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                                 ^
prog.c:281:97: note: (near initialization for 'x')
prog.c:281:99: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                                   ^
prog.c:281:99: note: (near initialization for 'x')
prog.c:281:101: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                                     ^
prog.c:281:101: note: (near initialization for 'x')
prog.c:281:103: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                                       ^
prog.c:281:103: note: (near initialization for 'x')
prog.c:281:105: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};
                                                                                                         ^
prog.c:281:105: note: (near initialization for 'x')
prog.c:281:107: warning: excess elements in array initializer
     int x[col]={0,0,1,0,0,1,0,1,0,0,0,1,1,1,0,0,1,0,1,0,1,1,1,1,0,1,1,0,1,0,0,1,0,0,0,0,0,0,0,0,0,1,1,0,1,1,1,1,0,0,1,1,1,1,0,1,1,1,0,1,1,0,1,0,1,0,1};

Re: C: warning: excess elements in array initializer

Jochen Arndt27-Aug-17 23:47

Jochen Arndt

27-Aug-17 23:47

Please stop posting such large code blocks (and repeating similar error messages). You question in QA brokes the system and lets the Firefox thread trying to show your message use 100 % CPU core load!

rog.c:60:34: error: expected ';', ',' or ')' before '&' token
 void ModulationSchemeValues (int &modulationScheme, int &noOfSymbols, double &var, float &d, int &col, float &rate, double &snr)

That is a C++ style function using references. C does not know references.

prog.c:281:105: note: (near initialization for 'x')
prog.c:281:107: warning: excess elements in array initializer
     int x[col]={0,0,1, ...

You are passing more initialisers to the array then specified. Don't use variable based sizes with initialised arrays. Just use

int x[] = {0,0,1,/* ... */ };

or specify the size literally.

Note also that such variable based array sizes are not supported by all compilers.

Re: C: warning: excess elements in array initializer

Richard Andrew x6430-Aug-17 14:06

Richard Andrew x64

30-Aug-17 14:06

Jochen Arndt wrote:
C does not know references

Are you sure? I used references in C when I was in school.

The difficult we do right away...
...the impossible takes slightly longer.

Re: C: warning: excess elements in array initializer

Jochen Arndt30-Aug-17 22:42

Jochen Arndt

30-Aug-17 22:42

I must confess that I have some difficulties to reply. I should have explained it in another way because naming something that does not exist for a specific subject is problematic.

C++ introduced the concept of a reference. These are mainly used for passing arguments. Then it is usually called pass-by-reference. This concept does not exist for C but the poster used C++ style function declarations using that C++ concept.

With C, passing arguments by pointers was (and still is) also called pass-by-reference. But passing by pointer is technically passing by value.

www-cs-students.stanford.edu/~sjac/c-to-cpp-info/references[^]:
In C, Pass-by-reference is simulated by passing the address of a variable (a
pointer) and dereferencing that address within the function to read or write
the actual variable. This will be referred to as "C style pass-by-reference."

Re: C: warning: excess elements in array initializer

Richard MacCutchan30-Aug-17 23:39

Richard MacCutchan

30-Aug-17 23:39

Jochen Arndt wrote:
But passing by pointer is technically passing by value.

No it is not. The pointer points to a variable, it is not the value, but its address (i.e. a reference to it). Consider:

C++

void PassByValue(int foo)
{
    // the value of foo is passed directly and may be manipulated here
    int i = foo + 5;
}

void PassByPointer(int* pFoo)
{
    // the value of foo must first be obtained by dereferencing pFoo
    int foo = *pFoo; // get the value into a local variable
    int i = foo + 5;
}

Re: C: warning: excess elements in array initializer

Jochen Arndt31-Aug-17 0:15

Jochen Arndt

31-Aug-17 0:15

pFoo is a value of type int*. If you change pFoo inside the function, the value of pFoo will be changed (the address) but not the value of the variable it points to. Therefore, it is technically passing by value.

Compare this with a reference parameter int& foo. If you change foo, the value of the referenced variable will be changed but not the hidden address.

Re: C: warning: excess elements in array initializer

Richard MacCutchan31-Aug-17 0:30

Richard MacCutchan

31-Aug-17 0:30

Jochen Arndt wrote:
pFoo is a value of type int*

No it is a pointer type, not a value type. And a reference type (which does not exist in C) is just a shorthand allowing you to modify a caller's value. But under the covers it behaves just the same as a pointer, thus:

C++

void PassByPointer(int* pFoo)
{
    *pFoo += 1;  // manipulates whatever pFoo points to
}

void PassByReference(int& rFoo)
{
    rFoo += 1;  // manipulates whatever rFoo refers (i.e. points) to
}

Re: C: warning: excess elements in array initializer

Jochen Arndt31-Aug-17 0:59

Jochen Arndt

31-Aug-17 0:59

A value is the content held by a variable. A pointer contains an address which is it's value.

Re: C: warning: excess elements in array initializer

Richard MacCutchan31-Aug-17 1:47

Richard MacCutchan

31-Aug-17 1:47

Semantics. Poke tongue | ;-P

Re: C: warning: excess elements in array initializer

Richard Andrew x6431-Aug-17 12:55

Richard Andrew x64

31-Aug-17 12:55

I appreciate the clarification.

However, in school we used the & to indicate a reference in C. As in:

C++

int PassByeReference(B& Parameter)

{
// Do something with B
}

The difficult we do right away...
...the impossible takes slightly longer.

Re: C: warning: excess elements in array initializer

k505431-Aug-17 13:21

k5054

31-Aug-17 13:21

Standard C does not know about references.

Also, strict ANSI C does not know about // style comments, but many modern C compilers do.

Possibly you were using a C++ compiler to compile c code?

Re: C: warning: excess elements in array initializer

Richard Andrew x6431-Aug-17 13:23

Richard Andrew x64

31-Aug-17 13:23

It was an early version of Borland Turbo C for DOS. Maybe they added the reference feature to the language?

The difficult we do right away...
...the impossible takes slightly longer.

Re: C: warning: excess elements in array initializer

k505431-Aug-17 13:47

k5054

31-Aug-17 13:47

That seems unlikely. I tried the following here : https://archive.org/details/msdos_borland_turbo_c_2.01, and got the expected compilation error

 #include <stdio.h>

void f(int &x) { x += 1; }

int main(void)
{
    int n = 1;
    printf("n = %d\n", n);
    f(n);
    printf("n = %d\n", n);

    return 0;
}

According to cppreference.com, references were added as early as 1985, and the compiler used above was 2.0, (c) 1990. Its not impossible that Borland added references before that, but them removed them later. Or added them at a later date when their C++ tools came out.

Re: C: warning: excess elements in array initializer

Jochen Arndt31-Aug-17 14:14

Jochen Arndt

31-Aug-17 14:14

I have learned C programming with Turbo C in the late 1980's and can't remember that it supported references.

Turbo C was discontinued as stand alone product in 1990 and the C compiler was included with Turbo C++ 1.0. So you probably used that.

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.