C / C++ / MFC

Sum Multiple Value At a Time

31-Aug-17 6:38

Finally, I solved my previous problem Re: Sum Multiple Value At a Time - C / C++ / MFC Discussion Boards[^]
I have a question in declaration why we declare sum = 0; if we declare only sum; what happen, what is the meaning of 0 and please clarify the function sum = sum+workhours; I have to understand whole thing.

#include<iostream>
using namespace std;
int main ()
{

    int sum = 0;
    int workhours;
    int numemployee;
    int employeewage;
    int wage = 0;


    cout << "Enter Number of Employee:";
    cin >> numemployee;

    for(int i=0;i<numemployee;i++)
    {
        cout << "Enter Employee Works Hours " << (i+1) <<":";
        cin >> workhours;
        sum=sum+workhours;
        cout << "Enter Work/hrs Wage " << (i+1) <<":";
        cin >> employeewage;
        wage=wage+employeewage;

    }
    cout << "Total Work Hours: " << sum <<endl;
    cout << "Total Wage:" << wage <<endl;
    return 0;
}

modified 12-Sep-17 8:50am.

Re: Declaration Confuse

leon de boer31-Aug-17 8:37

leon de boer

31-Aug-17 8:37

Well two problems if we imagine it uninitialized that is it will have some random value. The start value could be any integer value.

1.) Your sum starts at some random value then you do this line
sum=sum+workhours;

So your answer is some random value + the work hours.
Why bother calculating anything the total is just some random number.

2.) You print the answer even if you had zero employees you would print some random value.
The compiler will actually throw a warning about this line using uninitialized value due to that

The take home message here is variables don't magically start at zero if you want them to start as zero you need to set it to zero.

There is one subtlety here that when you are in debug mode it will initialize all variables to zero. That doesn't happen in release mode.
So new users when debugging often get caught out because when they look in debug mode sum will start as zero.

So the key here is don't set it to zero, compile in release mode ignoring the warning and run your code and watch some random number display. You will have your answer.

In vino veritas

modified 31-Aug-17 14:46pm.

Mr. Anup Roy30-Aug-17 6:18

30-Aug-17 6:18

Hi,
I am a beginner in C++. Today my first program is summed two value.
Question: Write a program that inputs the number of hours that an employee works and the employee wage. Then display the employee gross pay(Be sure promote to input).
I have a question here I input two value and calculate their result and display, but I want to input more than two value. How to input more than two value and calculate them?

#include<iostream>
using namespace std;
int main()
{
    int i, m, j, n, k, l;
    cout <<"Enter Your Work Hour:.\n";
    cin >>i >>m;
    cout << "Enter Your Salary:.\n";
    cin >> k >> n;
    j = i+m;
    l = k+n;
    cout << "Your Total Work Hour is:" << j <<endl;
    cout << "Your Total Salary is:" << l <<endl;
    return 0;
}

C++

jeron130-Aug-17 8:10

jeron1

30-Aug-17 8:10

By 'more than two' do you mean a variable number of inputs, or a fixed number?

"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

Mr. Anup Roy31-Aug-17 4:25

31-Aug-17 4:25

Variable number of input..

jeron131-Aug-17 5:38

jeron1

31-Aug-17 5: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.

David Crow30-Aug-17 10:31

David Crow

30-Aug-17 10: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

Mr. Anup Roy31-Aug-17 4:27

31-Aug-17 4:27

Hi David,
I got it thanks for your help.

CWinThread Termination

Lakshminaryana A29-Aug-17 18:38

Lakshminaryana A

29-Aug-17 18: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.

Richard MacCutchan29-Aug-17 21:02

29-Aug-17 21:02

Why not just use the features that are available?

Jochen Arndt29-Aug-17 21:27

29-Aug-17 21: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.

Lakshminaryana A29-Aug-17 23:17

Lakshminaryana A

29-Aug-17 23:17

Thank you for your response

I want to terminate the ThreadProc from outside of the thread

Jochen Arndt29-Aug-17 23:33

29-Aug-17 23: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[^].

Victor Nijegorodov30-Aug-17 5:54

Victor Nijegorodov

30-Aug-17 5: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!

C: warning: excess elements in array initializer

David Crow30-Aug-17 10:27

David Crow

30-Aug-17 10:27

See the OP's response here.

Member 1326117527-Aug-17 22:27

Member 13261175

27-Aug-17 22: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 22:47

Re: C: warning: excess elements in array initializer

27-Aug-17 22: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.

Richard Andrew x6430-Aug-17 13:06

Richard Andrew x64

30-Aug-17 13: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 21:42

Re: C: warning: excess elements in array initializer

30-Aug-17 21: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."

Richard MacCutchan30-Aug-17 22:39

Re: C: warning: excess elements in array initializer

30-Aug-17 22: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;
}

Jochen Arndt30-Aug-17 23:15

Re: C: warning: excess elements in array initializer

30-Aug-17 23: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.

Richard MacCutchan30-Aug-17 23:30

Re: C: warning: excess elements in array initializer

30-Aug-17 23: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
}

Jochen Arndt30-Aug-17 23:59

Re: C: warning: excess elements in array initializer

30-Aug-17 23:59

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

Richard MacCutchan31-Aug-17 0:47