Re: C: warning: excess elements in array initializer - C / C++ / MFC Discussion Boards

Re: CWinThread Termination

Richard MacCutchan29-Aug-17 21:02

Richard MacCutchan

29-Aug-17 21:02

Why not just use the features that are available?

Re: CWinThread Termination

Jochen Arndt29-Aug-17 21:27

Jochen Arndt

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.

Re: CWinThread Termination

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

Re: CWinThread Termination

Jochen Arndt29-Aug-17 23:33

Jochen Arndt

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[^].

Re: CWinThread Termination

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!

Re: CWinThread Termination

David Crow30-Aug-17 10:27

David Crow

30-Aug-17 10:27

See the OP's response here.

"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

C: warning: excess elements in array initializer

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

Jochen Arndt

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.

Re: C: warning: excess elements in array initializer

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

Jochen Arndt

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."

Re: C: warning: excess elements in array initializer

Richard MacCutchan30-Aug-17 22:39

Richard MacCutchan

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;
}

Re: C: warning: excess elements in array initializer

Jochen Arndt30-Aug-17 23:15

Jochen Arndt

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.

Re: C: warning: excess elements in array initializer

Richard MacCutchan30-Aug-17 23:30

Richard MacCutchan

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
}

Re: C: warning: excess elements in array initializer

Jochen Arndt30-Aug-17 23:59

Jochen Arndt

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

Richard MacCutchan

31-Aug-17 0:47

Semantics. Poke tongue | ;-P

Re: C: warning: excess elements in array initializer

Richard Andrew x6431-Aug-17 11:55

Richard Andrew x64

31-Aug-17 11: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 12:21

k5054

31-Aug-17 12: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 12:23

Richard Andrew x64

31-Aug-17 12: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 12:47

k5054

31-Aug-17 12: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 13:14

Jochen Arndt

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

Error deleting first column in CListCtrl

Member 86892625-Aug-17 10:09

Member 868926

25-Aug-17 10:09

Hi,
I am generating a CListCtrl in Report view (MFC). It loads fine and I can reorder columns by dragging the headers. I've made it so clicking a column header deletes the column - again this works fine except for the first (leftmost) column. Here the header is deleted but the data underneath doesn't change - in fact the data from the last column is deleted:

Before:

Header1    Header2     Header3

 Data1      Data2       Data3

After trying to delete first column:

Header2     Header3

 Data1       Data2

Having created the columns to begin with, I'm setting up the rest of the table like this:

void MyClass::InsertItem(int x, int y, CString &str)
{

    LVITEM lvi;
    lvi.mask = LVIF_TEXT;
    lvi.iItem = y;
    lvi.iSubItem = x;
    lvi.pszText = (LPTSTR)(LPCTSTR)(str);
    int result;
    if(x == 0)    {
        result = mCSVListCtrl.InsertItem(&lvi); 
    }
    else {
        result = mCSVListCtrl.SetItem(&lvi); 
    }
}

which seems to create the table OK. Then when a header is clicked:

void MyClass::OnLvnColumnclickList(NMHDR *pNMHDR, LRESULT *pResult)
{
    LPNMLISTVIEW pNMLV = reinterpret_cast<LPNMLISTVIEW>(pNMHDR);

    mCSVListCtrl.DeleteColumn(pNMLV->iSubItem);// This IS getting zero

    *pResult = 0;
}

Any ideas?

Re: Error deleting first column in CListCtrl

Rick York25-Aug-17 12:35

Rick York

25-Aug-17 12:35

Either look using the debugger or put in a trace statement but make sure the sub item value is what you expect it to be.

That's the only idea I have because I know that calling DeleteColumn(0) works because I do it often. One of the weird things with the list control is you can't set the first column to be right-justified so the work-around is to add one more column than needed, set column 1 to be right-justified, and then delete column 0. BTW - this was true with older versions and I don't know if it is still necessary. I do it anyway because it still works.

Re: Error deleting first column in CListCtrl

Member 86892626-Aug-17 11:00

Member 868926

26-Aug-17 11:00

Thanks for the various replies. The debugger doesn't go beyond DeleteColumn() but I can see it's passing zero. Can you see anything odd about the way I'm creating my sub items that could be causing the problem? I've created the columns first then for each item (row) I'm adding subitems left to right. Otherwise I'll have to go for the dummy first column option.

Re: Error deleting first column in CListCtrl

David Crow25-Aug-17 16:41

David Crow

25-Aug-17 16:41

What happens if you create a "dummy" column 0 with a width of 0 (or maybe 1)?

Re: Error deleting first column in CListCtrl

Jochen Arndt25-Aug-17 22:31

Jochen Arndt

25-Aug-17 22:31

Not a solution to the problem but a tip.

Instead of deleting columns you might set the width to zero. Then you can implement a hide/show column handler (which requires storing the actual or a default width for each column when hiding to be restored when showing it again).

Note also that it might be necessary to get the effective column index when the columns has been reordered (GetColumnOrderArray).

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