Is it possible to determine whether a string is "read-only"?

Question

Is it possible to determine whether a string can not be written on the side it had been passed to as a char * string?

my code:

#include <stdio.h>

typedef enum string_type 
    { READ_ONLY, READ_WRITE }
    String_type;

String_type isvalid(char *s);

void test(char *s){
    if(isvalid(s))
        printf("OK\n");
    else
        printf("NG\n");
}

int main(void){
    char data_str[] = "data_str";

    test("data_str");// fails
    test(data_str);// works

    return 0;
}

String_type isvalid(char *s){
    //Can it be determined by this?
    //I don't think this is a portable way.
    return (void *)s > (void *)main ? READ_ONLY : READ_WRITE;
}

Answer 1

Is it possible to determine whether a string is “read-only”?

There is no standardised way to do this.

Using addresses might also fail miserably on even one platform, as linkers are free to place data where they (the developers mastering them) want.

---

Update:

To prevent code passing literals to functions which themselfs try to modify the memory being passed in you might like to run a statical source analyser against the code.

A good tool to use for this is splint.

Answer 2

Totally arbitrary, but perhaps you can make it stable on your platform.

#include <stdio.h>
#include <stdlib.h>

int isliteral(char *s) {
    char *lit = "totally literal";
    char nolit[] = "some";
    return abs(nolit - s) > abs(lit - s) ;
}

int main(){
    char sa[] = "not literal";
    char *sl  = "literal";
    printf("%d\n", isliteral(sa));
    printf("%d\n", isliteral(sl));
    return 0;
}

Gives:

0
1

Answer 3

If you want to change a string I suggest you create a copy of the string, change that, and leave it up to the caller what they want to do with it.

char* change(char* original)
{
  int len = strlen(original);
  char* copy = new char[len + 1];
  strcpy(copy, original);
  copy[0] = 'H';
  return copy;
}

int main()
{
  char* data_str = "Bello world";

  const char* first_changed = change(data_str);
  const char* second_changed = change("Bello world");

  cout << first_changed << endl;
  cout << second_changed << endl;

  delete[] first_changed;
  delete[] second_changed;

  return 0;
}

Even better: use std::string and be freed of the burden of new/deleteing your character arrays.

Answer 4

constant is a compile time concept , but there is one exception that is for pointers , since c-string = char * so there will be possible to know if a char* is read-only at runtime :

#include <iostream>
#include <typeinfo>
int main()
{
    char * str1;
    const char *  str2 = "str2";
    std::cout<<"char * : "<<typeid(str1).name()<<"\n";
    std::cout<<"const char * : "<<typeid(str2).name()<<"\n";
    system("pause");
}

the output is :

char * : Pc
const char * : PKc
Appuyez sur une touche pour continuer... // press any key to continue