Is it bad to not define a static array size in a class?--but rather to let it autosize

Question

Ex: Is this acceptable? It compiles and seems to work for me; so is this bad form?

.h file

class MyClass
{
  static char c[];
};

.cpp file

char MyClass::c[] = "abcde";

---

Or must I do this instead, for example?

.h file

class MyClass
{
  static char c[10];
};

.cpp file

char MyClass::c[10] = "abcde";

Is there a benefit to one technique over the other? I'm not sure if I'm missing something. I don't know what I don't know, ya know?

Update:

The original code I posted looked like this below. I edited it to make it as shown above since I didn't mean for the "private" aspect of it to be the point of discussion. In my real code (running on an Arduino), I am using .h and .cpp files and the static member is only intended to be accessed by the class. I guess I'm learning something new though too, as the answers regarding the below code seem to tell me that private static members are the same as public static members ie: they can both be modified by anything outside the class if static. That, I didn't know. WRONG, see the answer by Alok Save here. More on static member variables here. This line was especially helpful to me: "Because static member variables are not part of the individual objects, you must explicitly define the static member if you want to initialize it to a non-zero value...This initializer should be placed in the code file for the class (eg. Something.cpp). In the absense of an initializing line, C++ will initialize the value to 0."

class MyClass
{
  private:
  static char c[];
};

char MyClass::c[] = "abcde";

---

Or must I do this instead, for example?

class MyClass
{
  private:
  static char c[10];
};

char MyClass::c[10] = "abcde";

Answer 1

The question seems to be about whether to explicitly write the size of the array, rather than to deduce it from the assignment. Consider this:

What if you need to change the string value that the array is initialized to? If you explicitly define the size, you will need to change it in 3 places. First in the class definition, second in the static variable assignment. And third, you will also end up changing the value of the string assigned. Not explicitly writing the array size allows you to make the change in only one place. Additionally, it eliminates the possibility of forgetting to add 1 for the null terminator at the end of the string.

Clearly, this simplifies future code changes and does not sacrifice code clarity.

Answer 2

Private variable should only access within ,it's class scope. when you ,put private without static ,it is safe and any one cannot access except with in class. in this case , I thin any one can change this variable , when creating a class.because this is static. he should ,only crate new class , and he know your variable name, he can change ,it value.

private variable should be private and that value should not access with out class method inside. please , visit OOP concept. you can get better idea. visit java access modifiers, you can take better idea.

you get take understand , why we put access modifiers.I think you , get some about your Question.

I think this is bad.

Answer 3

Considering the member is private, nothing outside of the class should be able to mutate it. So neither piece of code should be used. Also, instead of using c-style arrays with c++, I would recommend you use the standard library std::valarray and std::vector for numerical and object data resp. and std::string for textual data.

You can read more about them in their docs.

As for your example:

class Object {
private:
    static int value[] = nullptr;

public:
   inline void setValue(int* newValue) {
        value = newValue;
    }
   inline int getValue() {
        return value;
    }
}

Object first{};
int a[10] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 
first.setValue(a)
std::cout << first.getValue(); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Object second{};

int b[1] = [1];
first.setValue(b)
std::cout << second.getValue(); // [1]

Answer 4

PLEASE CORRECT ME IF I'M WRONG, BUT THIS IS THE ANSWER THAT CLARIFIES MY CONFUSION THE MOST. Refer to the code comments, marked by //<--. These are my answer. Is this correct?

.h file

class MyClass
{
  static char c[]; //<--this allocates memory for a pointer, 
                   //and makes it a null pointer since it doesn't
                   //point anywhere yet
};

.cpp file

char MyClass::c[] = "abcde"; //<--this allocates 6 bytes 
  //(5 chars + null terminator) for the string, AND now 
  //sets the above pointer to point to the starting byte
  //of this newly allocated memory.