Jika saya don't tahu berapa lama kata ini, saya tidak bisa menulis char m[6];
,
Panjang kata adalah mungkin sepuluh atau dua puluh panjang.
Bagaimana saya bisa menggunakan scanf
untuk mendapatkan input dari keyboard?
#include <stdio.h>
int main(void)
{
char m[6];
printf("please input a string with length=5\n");
scanf("%s",&m);
printf("this is the string: %s\n", m);
return 0;
}
mohon masukan string dengan panjang=5 halo ini adalah string: hello
Masukkan sekaligus mengamankan daerah yang dinamis
E. G.
#include <stdio.h>
#include <stdlib.h>
char *inputString(FILE* fp, size_t size){
//The size is extended by the input with the value of the provisional
char *str;
int ch;
size_t len = 0;
str = realloc(NULL, sizeof(char)*size);//size is start size
if(!str)return str;
while(EOF!=(ch=fgetc(fp)) && ch != '\n'){
str[len++]=ch;
if(len==size){
str = realloc(str, sizeof(char)*(size+=16));
if(!str)return str;
}
}
str[len++]='\0';
return realloc(str, sizeof(char)*len);
}
int main(void){
char *m;
printf("input string : ");
m = inputString(stdin, 10);
printf("%s\n", m);
free(m);
return 0;
}
Dengan komputer ini, anda bisa lolos dengan mengalokasikan sangat besar string (ratusan ribu karakter) sementara tidak membuat penyok dalam komputer's penggunaan RAM. Jadi saya tidak't khawatir terlalu banyak.
Namun, di hari tua, ketika memori adalah pada premium, praktek umum adalah untuk membaca string dalam potongan. fgets
membaca sampai maksimum jumlah karakter dari input, tetapi meninggalkan sisa input buffer utuh, sehingga anda dapat membaca sisa dari itu namun anda suka.
dalam contoh ini, saya baca di potongan dari 200 karakter, tetapi anda dapat menggunakan apapun potongan ukuran yang anda inginkan tentunya.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
char* readinput()
{
#define CHUNK 200
char* input = NULL;
char tempbuf[CHUNK];
size_t inputlen = 0, templen = 0;
do {
fgets(tempbuf, CHUNK, stdin);
templen = strlen(tempbuf);
input = realloc(input, inputlen+templen+1);
strcpy(input+inputlen, tempbuf);
inputlen += templen;
} while (templen==CHUNK-1 && tempbuf[CHUNK-2]!='\n');
return input;
}
int main()
{
char* result = readinput();
printf("And the result is [%s]\n", result);
free(result);
return 0;
}
Perhatikan bahwa ini adalah contoh sederhana dengan tidak memeriksa kesalahan; dalam kehidupan nyata anda akan memiliki untuk memastikan bahwa masukan yang OK dengan memverifikasi kembali nilai fgets
.
Perhatikan juga bahwa pada akhirnya jika readinput rutin, tidak ada byte yang terbuang; string telah yang tepat ukuran memori yang dibutuhkan untuk memiliki.
I've terlihat hanya satu simple cara membaca yang sewenang-wenang panjang string, tapi aku've tidak pernah digunakan. Saya pikir itu berjalan seperti ini:
char *m = NULL;
printf("please input a string\n");
scanf("%ms",&m);
if (m == NULL)
fprintf(stderr, "That string was too long!\n");
else
{
printf("this is the string %s\n",m);
/* ... any other use of m */
free(m);
}
M
antara %
dan s
memberitahu scanf()
untuk mengukur string dan mengalokasikan memori untuk itu dan menyalin string ke dalam, dan untuk menyimpan alamat memori yang dialokasikan sesuai argumen. Setelah anda're selesai dengan itu anda harus gratis()
itu.
Ini isn't didukung pada setiap pelaksanaan scanf()
, meskipun.
Seperti orang lain telah menunjukkan, solusi termudah adalah untuk menetapkan batas pada panjang input. Jika anda masih ingin menggunakan scanf()
maka anda dapat melakukannya dengan cara ini:
char m[100];
scanf("%99s",&m);
Perhatikan bahwa ukuran m[]
harus setidaknya satu byte lebih besar dari jumlah antara %
dan s
.
Jika string yang dimasukkan adalah lebih dari 99, maka sisa karakter akan menunggu untuk dibaca oleh panggilan lain atau oleh seluruh format string yang dilewatkan ke scanf()
.
Umumnya scanf()
adalah tidak dianjurkan untuk penanganan input pengguna. It's best diterapkan untuk dasar teks terstruktur file yang dibuat oleh aplikasi lain. Bahkan kemudian, anda harus menyadari bahwa input mungkin tidak bisa diformat seperti yang anda harapkan, sebagai seseorang yang mungkin telah mengganggu itu untuk mencoba untuk memecahkan program anda.
Kalau boleh saya menyarankan sebuah pendekatan yang lebih aman:
Menyatakan penyangga yang cukup besar untuk menyimpan string:
char user_input[255];
Mendapatkan input pengguna dalam aman cara:
fgets(user_input, 255, stdin);
Cara yang aman untuk mendapatkan masukan, argumen pertama menjadi pointer ke buffer dimana input akan disimpan, kedua input maksimum fungsi harus membaca dan yang ketiga adalah pointer ke standar input - yaitu di mana pengguna input berasal dari.
Keselamatan secara khusus datang dari argumen kedua membatasi berapa banyak yang akan membaca yang mencegah buffer overruns. Juga, fgets
mengurus null-mengakhiri diproses string.
Info lebih lanjut tentang itu fungsi disini.
EDIT: Jika anda perlu untuk melakukan format (misalnya mengkonversi string ke number), anda dapat menggunakan atoi setelah anda memiliki masukan.
Lebih aman dan lebih cepat (dua kali lipat kapasitas) versi:
char *readline(char *prompt) {
size_t size = 80;
char *str = malloc(sizeof(char) * size);
int c;
size_t len = 0;
printf("%s", prompt);
while (EOF != (c = getchar()) && c != '\r' && c != '\n') {
str[len++] = c;
if(len == size) str = realloc(str, sizeof(char) * (size *= 2));
}
str[len++]='\0';
return realloc(str, sizeof(char) * len);
}
Mengambil karakter pointer untuk menyimpan diperlukan string.Jika anda memiliki beberapa ide tentang kemungkinan ukuran dari string maka gunakan fungsi
char *fgets (char *str, int size, FILE* file);`
lain anda dapat mengalokasikan memori pada saat runtime juga menggunakan malloc() fungsi yang secara dinamis memberikan diminta memori.
Saya tahu bahwa saya telah tiba setelah 4 tahun dan saya terlambat tapi saya pikir saya punya cara lain bahwa seseorang dapat menggunakan. Saya telah menggunakan getchar()
Fungsi seperti ini:-
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
//I had putten the main Function Bellow this function.
//d for asking string,f is pointer to the string pointer
void GetStr(char *d,char **f)
{
printf("%s",d);
for(int i =0;1;i++)
{
if(i)//I.e if i!=0
*f = (char*)realloc((*f),i+1);
else
*f = (char*)malloc(i+1);
(*f)[i]=getchar();
if((*f)[i] == '\n')
{
(*f)[i]= '\0';
break;
}
}
}
int main()
{
char *s =NULL;
GetStr("Enter the String:- ",&s);
printf("Your String:- %s \nAnd It's length:- %lu\n",s,(strlen(s)));
free(s);
}
berikut adalah contoh untuk menjalankan program ini:-
Enter the String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!!
Your String:- I am Using Linux Mint XFCE 18.2 , eclispe CDT and GCC7.2 compiler!!
And It's length:- 67
saya juga punya solusi dengan standar input dan output
#include<stdio.h>
#include<malloc.h>
int main()
{
char *str,ch;
int size=10,len=0;
str=realloc(NULL,sizeof(char)*size);
if(!str)return str;
while(EOF!=scanf("%c",&ch) && ch!="\n")
{
str[len++]=ch;
if(len==size)
{
str = realloc(str,sizeof(char)*(size+=10));
if(!str)return str;
}
}
str[len++]='\0';
printf("%s\n",str);
free(str);
}
Baca langsung ke ruang yang dialokasikan dengan fgets()
.
Perawatan khusus ini perlu untuk membedakan yang sukses baca, end-of-file, kesalahan input dan out-of memory. Tepat manajemen memori yang dibutuhkan pada EOF.
Metode ini mempertahankan garis's '\n'
.
#include <stdio.h>
#include <stdlib.h>
#define FGETS_ALLOC_N 128
char* fgets_alloc(FILE *istream) {
char* buf = NULL;
size_t size = 0;
size_t used = 0;
do {
size += FGETS_ALLOC_N;
char *buf_new = realloc(buf, size);
if (buf_new == NULL) {
// Out-of-memory
free(buf);
return NULL;
}
buf = buf_new;
if (fgets(&buf[used], (int) (size - used), istream) == NULL) {
// feof or ferror
if (used == 0 || ferror(istream)) {
free(buf);
buf = NULL;
}
return buf;
}
size_t length = strlen(&buf[used]);
if (length + 1 != size - used) break;
used += length;
} while (buf[used - 1] != '\n');
return buf;
}
Contoh penggunaan
int main(void) {
FILE *istream = stdin;
char *s;
while ((s = fgets_alloc(istream)) != NULL) {
printf("'%s'", s);
free(s);
fflush(stdout);
}
if (ferror(istream)) {
puts("Input error");
} else if (feof(istream)) {
puts("End of file");
} else {
puts("Out of memory");
}
return 0;
}